当前位置：首页 > 编程语言 > # Python基础

# Python基础

2021-03-08 17:30

阅读：607

标签：属性绑定   面向过程   重用   lse   case   star   开始   超过   形参与实参   

一、前言（总结）

1. 运行python程序的两种方式

交互式

  • 即时得到程序的运行结果，多用于调试

脚本的方式

  • 把程序写到文件里（约定俗成后缀为.py），用python解释器解释其中的内容
  • 用python python程序文件的路径

2. python程序运行的三个步骤

  • python C:\x\x\x. py
    1. 先启动python 3.8解释器
    2. 解释器发送系统调用，把x. py的内容从硬盘读入内存，此时x. 的内容全为普通字符，无语法意义
    3. 解释器开始解释执行刚刚读入内存的x. py的代码，开始识别python语法
  • 对比文本编辑器读取 C:\x\x\x. py文件内容的三个步骤 
    • 1. 先启动文本编辑器
      1. 文本编辑器会发送系统调用，把x. py的内容从硬盘读入内存
        . 文本编辑器会将刚刚读入内存的内容控制输出到屏幕上，让用户看到结果（不会检查语法）
  • 总结：
      1. 二者在前两个阶段所做的事情完全一致
      1. 唯一不同的就是第三个阶段对读入内存的python代码处理方式不同

4.注释

    1. 注释是对代码的解释说明
    2. 被注释的代码不会被执行
    3. 为关键代码加注释

注释的形式

    1. #
      • 可以写在代码前一行，也可以写在同一行
      • 写在同一行时，需要空两个空格
    1. """ """ / ‘‘‘ ‘‘‘
      • 可以用来写单行注释，也可以用来写多行注释

二、基础

1. 变量

  1. 什么是变量？

    1. 变量是可以变化的量，量指事物的状态，比如年龄，性别，身高等。

  2. 为什么要有变量

    1. 为了让计算机能够像人一样去记忆事务的某种状态，并且状态可以改变。
    2. 程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化。

  3. 变量的基本使用

    原则：先定义后引用

    name = ‘Stephane‘  # 定义
print(name)  # 引用

    Python的值传递都是引用传递（内存地址的传递）

    1. 内存管理：垃圾回收机制

      1. 垃圾：当一个变量值被绑定的变量名的个数为0，该变量值无法被访问到，称之为垃圾

      2. 引用数：变量绑定变量名的个数

        1. 引用数增加
        x = 10  # 10的引用次数为1
y = x   # 10的引用次数为2
z = y   # 10的引用次数为3
        1. 使引用数减少的方式

    2. del解除绑定

        2. 变量名指向另一个变量

      x = 10  # 10的引用次数为1
y = x  # 10的引用次数为2
z = y  # 10的引用次数为3
del x  # 10的引用次数为2
del y  # 10的引用次数为1

    3. 直接引用与间接引用：

    • 直接引用：直接与值关联
      • 栈区指向堆区
    • 间接引用：将值放进容器（如字典、列表等）关联
      • 堆区指向堆区

    1. 变量组成部分：

      1. 变量名：是指向等号右侧值的内存地址的，用来访问等号右侧的值

  4. 赋值符号： = 将变量值的内存地址绑定给变量名

    1. 变量值：代表记录的事物的状态

    2. 变量命名：

    3. 命名基础

      原则： 变量名应该见名知意

      1. 只能由字母、数字、下划线组成

    4. 不能用数字开头

      1. 不能使用关键字或内置函数命名变量

      ps：尽量不要用拼音，不要用中文，在见名知意的情况下，尽可能短

  5. 命名风格

    1. 纯小写加下划线的方式

    2. 驼峰体

    3. 变量值的三个重要特征

  6. id：反映的是变量值的内存地址（id不是地址），内存地址不同，则id不同

    1. id不同，值可能相同
    2. id相同，值一定相同
         name = stephane
print(id(name))

    2. type：不同类型的值表示记录不同的状态

         name  = stephane
print(type(name))

    3. value：值本身

         name = stephane
print(name)

    5. is 与 ==

    1. is：比较左右两值身份id是否相等

      一般来说，两个值相等的整数变量id相同（[-5, 256]），因为python解释器在启动之时就会在内存中事先申请一部分空间放入一系列常用的整数，被称为小整数池,事实上其他变量也有类似优化

    2. ==：比较左右两个值是否相等

2. 数据类型（该处没有集合和元组）

  1. 数字类型

    1. int 整型

      1. 作用：记录年龄、号码、个数等的整数变量

      2. 定义：变量名 = 整数

        age = 18
print(type(age))  # int

    2. float 浮点型

      1. 作用：记录小数、身高体重等的小数变量

      2. 定义：变量名 = 小数

        height = 1.78
 print(type(height))  # float

    3. 数字类型的其他使用

      1. 变量进行算术运算后的结果可以赋值给另一个数字变量
        2. 数字变量可以自加
        3. 可以输出一个算式的结果
        4. int 可与float之间进行算术运算

  2. 字符串类型

    1. 作用：记录描述性质的状态、名字、一段话等

    2. 定义：用（‘ ‘," ",‘‘‘ ‘‘‘,""" """）包含的一串字符

      str1 = ‘19‘
str2 = "Hi"
str3 = ‘Do you know "Python"?‘
str4 = "I‘m a engineer!"
str5 = ‘I\‘m a engineer‘
# str6和str7赋值的字符串可换行，输出形式包括换行
str6 = ‘‘‘Hello world‘‘‘
str7 = """Hello
everyone!"""

    3. 其他使用：

      1. 内层和外层不能同时为单引号或同时为双引号
      2. 字符串之间可以相加（效率极低）
      3. 字符串与数字（整型）相乘，会重复输出相应遍的字符串

  3. 列表类型：索引对应值，从0开始

    1. 作用：记录多个值，并且按照索引取指定位置的值

    2. 定义：在中括号内用逗号分隔开多个任意类型值的元素，一个值称为一个元素

      list1 = [0, 0, 2, 6]
print(list1[3])  # 2

    3. 其他使用：

      1. 嵌套取值
      2. 排序
      3. 遍历
      4. 查找等

    4. 在内存中的存储方式：

      1. 在每一个索引中存储着值所对应的地址
      2. 地址对应相应的元素所在的空间

  4. 字典类型：key对应值，其中key通常为字符串类型，key对值有描述性的功能

    1. 作用：存多个值，每个值都有唯一一个key与之对应，key对值有描述作用

    2. 定义：在{}中由逗号分开为多个key: value，key必须是不可变类型，value可以是任意类型

      dict1 = {"Name": "Stephane", "Age": 19, "height": 178}
print(dict["Name"])  # Stephane

    3. 其他使用：

      1. 嵌套取值
      2. key遍历
      3. key-value遍历等

  5. 布尔类型

    1. 作用：用来记录真假两种状态

    2. 定义：True False

      a = True
b = False

    3. 其他使用：用来当作判断条件

  6. 可变不可变类型

    1. 定义：
      1. 可变类型：值改变，id不变，改的是原值
      2. 不可变类型：值改变，id改变，产生了新的值，没有改变原值，即只能通过赋值来改变值
    2. 验证：
      1. 不可变类型：（int float str被设计成了不可分割的整体，不能被改变）
        • 整型
        • 浮点型
        • 字符串类型
        • 布尔类型
        • 元组
      2. 可变类型：
        • 列表
        • 字典

3. 垃圾回收机制详解

  1. 定义：垃圾回收机制（GC）是Python解释器的一种机制，专门用来回收不可用的变量值所占用的空间

  2. 引用计数

    x = 10
print(x)  # 10

l = [10, x]  # 间接引用
dict1 = {"age": x}  # 间接引用
z = x  # 直接引用

# id相同
print(id(x))  # 直接引用
print(id(l[1]))

  3. 标记清除

    1. 变量存储位置
      1. 变量名存在栈区，同时指向一块地址
      2. 变量名指向的地址在堆区中，存放变量值
      3. python垃圾回收机制管理的是堆区（当堆区地址被回收，栈区地址自然亦被回收）
    2. 标记清除
      • 解释器运行一段时间，扫描栈区内存，若堆区的变量值没有被直接引用，则将其清除

  4. 分代回收

    1. 背景：每次回收内存，都需要把所有对象的引用计数都遍历一遍，浪费时间，于是引入分代回收，采用“空间换时间”的策略

    2. 分代回收的核心思想：在历经多次扫描的情况下，都没有被回收的变量，GC机制认为其比较常用，于是降低对此类变量的扫描频率，依据权重，将其分为多个代，权重越高，扫描频率越低

4. 用户交互

  1. 接受用户输入

    • python3
      • input()
    • python2.7
      • input()
        • 用户必须明确输入的数据类型，即该函数会识别输入的类型
      • raw_input()
        • 用法同python3中的input()

  2. 字符串格式化输出

    • print()

      • %

        1. python诞生之初就有，兼容性最好
        2. %用法与C语言中printf()中类似
        3. %s中不止可以引用字符串
        name = ‘Stephane‘
age = 18

print(‘My name is %s, I am %d‘ % (name, age))
print(‘My name is %(name)s, I am %(age)d‘ % {‘name‘: ‘Ste‘, ‘age‘: 18})  # 字典形式

      • （重要）str.format()（python2.6及之后可用）

        1. 用来进行字符串格式化的函数（非输出函数）

        2. 在()中写变量名，在str中变量名由{}代替{}中数字代表变量序号

        3. 可以用字典的键值对传值

        4. 在str中可用一些格式使某个特定字符对字符串进行填充

          • : 表示有附加的字符
          • 表示原字符串左对齐，>表示右对齐，^表示居中显示
          • >或
          • 不能用空格填充

    • 若变量之前已赋值有变量值，则可以使用索引进行标记，否则需要使用变量名进行标记

      # 使用索引标记
name = ‘Stephane‘
age = 18

print("My name is {0}, I am {1}".format(name, age))

# 使用变量名标记
print("Today is {week}.".format(week=‘Mon‘))

  • 最后的数字表示字符串总长度（若无附加字符时，就已超过总长度，则不会出现附加字符）

    1. str中可对数据做一些精度要求

    • 变量后可跟:.精度+f，表示精确到某位小数

    • f‘ ‘（python3.5及以后可用但效率低）

      1. f‘格式化字符串‘

      2. 变量由{}括起

      3. {}内的字符串可以被当作表达式运行

      name = ‘Stephane‘
age = 18

print("My name is {0}, I am {0}".format(name, age))

res = ("My age is {age}, I am {name}".format(name=‘ZHS‘, age=18))
print(res)

print(‘{x:=
name = ‘Stephane‘
age = 18
print(f‘My name is {name}, and I am {age} years old.‘)
print(f‘10+3‘)  #  10+3
print(f‘{10+3}‘)  #  13
f"{print(‘abcd‘)}"  #  abcd

?

5. 基本运算符

  1. 算术运算符

    2. -
    3. *
    4. **
    5. / 除以
    6. // 整除
    7. % 取模

  2. 赋值运算符

    1. =

    2. 增量赋值

      1. +=
      2. -=
      3. *=
      4. /=
      5. //=
      6. **=

    3. 链式赋值

      • 变量1 = 变量2 = 变量3 = ... = value

    4. 交叉赋值（交换变量值）

      • python提供了更简单的方式
      • 变量1, 变量2 = 变量2, 变量1
      a = 10
b = 20
a, b = b, a
print(a, b)  #  20 10

    5. 解压赋值（若解压字典，默认解压key）

      1. 将列表中的元素拆分为单独变量并一一对应
      2. 元素一般与对应变量个数相同
        • 若变量数小于元素数（取前n个元素）
          1. 可对列表做切片处理
          2. 一般可在已知变量最后加*_（其他的名字也可以），接受剩余的所有元素，形成一个剩余元素组成的列表
        • 若变量数小于元素数（取后n个元素）
          1. 可对列表做切片处理
          2. 一般可在已知变量之前加*_接受剩余的所有元素，形成一个剩余元素组成的列表
      3. 原列表仍存在
      list1 = [1, 2, 3, 4]
a, b, c, d = list1
print(a, b, c, d)  #  1 2 3 4
print(list1)  #  [1, 2, 3, 4]


      list1 = [1, 2, 3, 4]
a, b, c, *_ = list1
print(a, b, c)  #  1 2 3
print(_)  #  [4]

  3. 比较运算符

    1. >
    3. >=
    5. ==
    6. !=

  4. 逻辑运算符：用来连接多个条件加以判断的运算符

    1. not：逻辑否
    2. and：逻辑与
    3. or： 逻辑或
    4. 优先级：
      1. 如果一串and连接或一串or连接，按照从左向右顺序依次运算即可
      2. 如果混用，考虑优先级（否 > 与 > 或）
    5. 短路运算：（偷懒原则，偷懒到哪个位置，就把哪个位置的值返回）
      1. 用and连接的条件如果前一个条件为假，则不判断后一个条件 结果一定为假
      2. 用or连接的条件如果前一个为真，则不判断后一个条件 结果一定为真
      3. 在同一模块中的if...elif...else...结构中，若执行一个，则其后面同等级的判断语句不被执行

  5. 成员运算符：

    1. in
      • 适用于可遍历的变量，判断子变量是否在大变量中
    2. not in
      • 适用于可遍历的变量，判断子变量是否不在大变量中

  6. 身份运算符：is

    • 如果若干个变量的id都相同，即指向同一块地址，则变量1 is 变量2 is 变量3的结果为True，反之，则为False

6. 流程控制

6.1 if判断

  1. 什么是if判断：判断条件是否成立的语句

  2. 为什么要有if判断：增强程序的流程多样性

  3. 怎么用：

    """
语法1：
if 条件:
	语句1
	语句2
	...

语法2：
if 条件:
	语句1
	...
else
	语句1
	...
	
语法3：
if 条件1:
	语句1
	...
elif 条件2:
	语句1
	...
...
else:
	语句1
	...
"""
  • if语句中若无执行语句也可加"pass"或"..."占位符，表示无语句执行

6.2 while循环（条件循环）

  1. while循环的语法与基本使用

    """
while 条件:
	代码1
	代码2
	...
"""

  2. 死循环与效率问题

    1. 死循环：不能结束的循环，循环条件永远为真
    2. 纯计算无IO的死循环会导致致命的效率问题

  3. 循环的应用

  4. 退出循环的两种方式

    1. 条件为假
    2. while + break：结束本层循环

  5. while循环嵌套

    """
while 条件1:
	语句1
	...
	while 条件2:
		语句2
		...
或
while 条件1:
	语句1
	...
	while 条件2:
		语句2
		...
		break
	break
"""

  6. while + continue：结束本次循环

  7. while + else

    """
while 条件:
	语句1
	...
else:
	语句2
	...
"""
    • else包含的代码在while循环结束后，并且while循环没有被break打断才会运行

6.3 for循环

  1. for循环的语法与基本使用

    1. 什么是for循环：for循环shipython提供的第二种循环机制

    2. 为什么要用for循环：

      1. 理论上for循环可以做的事情，while循环也可以做
      2. 在循环取值（遍历取值）上for循环更简洁

    3. 如何用for循环：

      """
for 变量名 in 可迭代对象:
# 可迭代对象可以是list,string,dictionary,set,tuple
	语句1
	语句2
	...
"""

  2. for循环应用

    1. for循环可以用来遍历
    2. for循环可以用来计数，range(self, stop, step)函数

  3. for循环嵌套

    """
for 变量名1 in 可迭代对象1:
	语句1
	for 变量名2 in 可迭代对象2:
		语句2
		...
"""

  4. for + break

  5. for + continue

  6. for + else

  7. while循环与for循环的异同：

    1. 异：
      1. while循环为条件循环，循环次数取决于条件何时为假
      2. for循环是取值循环，循环次数取决于可迭代对象元素个数，中止for循环只能用break
    2. 同：都是循环，while循环的能量大于for循环

7. 深浅copy

7.1 深copy

  • 导入copy模块

  • 使用函数copy.deepcopy()

  • 在两个变量中对于任意不可变类型变量，指向的地址都相同，对于任意可变类型，指向地址都不同

    ![](引用图像\批注 2020-07-30 000912.png)

7.2 浅copy

  • copy后，二者指向同一块地址（把原可变类型第一层内存地址不加区分完全copy一份给新的可变类型），对任意一个元素改变，则会对地址指向的内容改变，即二者内容都会更新
  • 直接将可变变量互相赋值，并使用非直接赋值方法进行修改，为浅copy
  • 使用.copy()函数，使不可变类型的元素修改独立开来，但对于可变类型元素，仍不可修改
  • Linux的文件硬链接也是浅copy

8. 基本数据类型及其内置方法

8.1 数字

8.1.1 int
  1. 作用：表示整数
  2. 定义：变量名 = 数字
  3. 类型转换：
    1. int() 也可用于其他进制转十进制
      • 当对象为字符串时，可用int(‘‘数字‘‘, 进制数)，数字为十进制时，可不写进制数
    2. bin() 转二进制
    3. oct() 转八进制
    4. hex() 转十六进制
  4. 使用：无内置方法
8.1.2 float
  1. 作用：表示非整数
  2. 定义：变量名 = 数字
  3. 类型转换：float()
  4. 使用：无内置方法
8.1.3 complex
  1. 作用：表示复数
  2. 定义：变量名 = 实部 +/- 虚部j
    1. 变量名.real = 数字 实部
    2. 变量名.img = 数字 虚部
  3. 类型转换：complex
  4. 使用：无内置方法

8.2 字符串

  1. 作用

  2. 定义：

    1. 变量名 = 字符串
    2. str.format

  3. 类型转换：str() 把任意其他类型转换成字符串

  4. 使用：

    1. 优先掌握

      1. 按索引取值

        # 正向取
str = "Hello"
print(str[1])  # e
# 反向取
print(str[-1])  # o
# 只能取
str[1] = ‘a‘  # 错误，字符串不可修改

      2. 切片（从一个大的字符串中拷贝出一个子字符串）

        # 左闭右开区间
str = "HelloWorld"
print(str[0:3])  # Hel
# 步长
print(str[0:5:2])  # Hlo (start = stop)

      3. 长度(len)

        str = "Hello"
print(len(str))  # 5

      4. 成员运算符 in 和 not in

        # 判断一个子字符串是否在大字符串中
str = "hello"
print(‘h‘ in str)  # True
print(‘a‘ not in str)  # True

      5. 移除空白 strip

        # strip只去两边，不去中间
str = " hello World "
print(str.strip())  # "hello world"
print(str.lstrip())  # "hello world "
print(str.rstrip())  # " hello world"
str1 = "********hello********"
print(str1.strip(‘*‘))  # "hello"

      6. 切分split

        # 把一个字符串按照某种分隔符（默认为空格）进行切分，得到一个列表（不包括分隔符）
# split(sep, maxsplit)
str = "a:b:c:d"
list1 = str.split(‘:‘)
print(list1)  # [‘a‘, ‘b‘, ‘c‘, ‘d‘]
list1 = str.split(‘:‘, 2)
print(list1)  # [‘a‘, ‘b‘, ‘c:d‘]

      7. 循环

        # for循环

    2. 需要掌握

      1. lower，upper

        str = "abCdEF"
print(str.lower())  # abcdef
print(str.upper())  # ABCDEF

      2. startswith, endswith

        str = "abcdefg"
print(str.startswith("abc"))  # True
print(str.endswith("efg"))  # True

      3. split, rsplit

        str = "a:b:c:d"
list1 = str.split(‘:‘)
print(list1)  # [‘a‘, ‘b‘, ‘c‘, ‘d‘]

list1 = str.rsplit(‘:‘)
print(list1)  # [‘a‘, ‘b‘, ‘c‘, ‘d‘]

list1 = str.rsplit(‘:‘, 2)
print(list1)  # [‘a:b‘, ‘c‘, ‘d‘]

      4. join

        # 将列表拼接成字符串
# 列表中每个元素为字符（串）
list1 = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
str1 = ‘:‘.join(list1)  # a:b:c:

      5. replace

        # replace(old, new, count)
str1 = "Hello World"
print(str1.replace("H", "U"))  # "Uello World"

      6. isdigit

        # 判断字符串是否由纯数字组成
str1 = "123123123123"
str2 = "1a2b3c"
print(str1.isdigit())  # True
print(str2.isdigit())  # False

    3. 了解

      1. find, rfind

        str1 = "Stephane"
# find和rfind若找不到会返回-1
print(str1.find(‘e‘))  # 2  返回查找字符串在大字符串中的起始索引
print(str1.rfind(‘e‘))  # 7  返回从右查找字符串在大字符串中的起始索引

      2. index, rindex

        str1 = "Stephane"
# index和rindex若找不到会直接报错
print(str1.find(‘e‘))  # 2  返回查找字符串在大字符串中的起始索引
print(str1.rfind(‘e‘))  # 7  返回从右查找字符串在大字符串中的起始索引

      3. count

        str1 = "Ada is Ada"
print(str1.count("Ada"))  # 2 返回目标字符串出现的次数

      4. center

        # center(wideth, fullchar) 使字符串居中，并用填充字符填充至指定长度
str1 = "hello"
print(str1.center(11, ‘*‘))  # ***hello***

      5. ljust

        # ljust(wideth, fullchar)使字符串左对齐，并用填充字符填充至指定长度
str1 = "hello"
print(str1.ljust(11, ‘*‘))  # hello******

      6. rjust

        # ljust(wideth, fullchar)使字符串右对齐，并用填充字符填充至指定长度
str1 = "hello"
print(str1.rjust(11, ‘*‘))  # ******hello

      7. zfill

        # zfill(wideth)使字符串右对齐，并用0填充至指定长度
str1 = "hello"
print(str1.rjust(11, ‘*‘))  # 000000hello

      8. expandtabs

        # expandtabs(tabsize)若字符串中有制表符，指定制表符所包含的空格数
str1 = "hello\tworld"
print(str1.expandtabs(2))  # hello  world

      9. capatalize

        # capatalize()使字符串首字母大写

      10. swapcase

        # swapcase()使字符串中的大小写反转

      11. title

        # title()使每个单词首字母大写

      12. is其他

        # islower()
# isupper()
# isspace()
# istitle()
# isalnum()
# isalpha()
# isidentifier() 判断是否为合法标识符
# isdecimal()
# isnumberic() 可判断数字、中文数字、罗马数字等

8.3 列表

  1. 作用：按位置存多个值

  2. 定义：list1 = [ ]

  3. 类型转换：list()可以转换能被for循环遍历的类型

  4. 使用

    1. 优先掌握

      1. 按索引存取值

        list1 = [111, 222, 333, 444]
# 正向取
list1[1]
# 反向取
list1[-1]
# 可修改
list1[0] = 100
list1[4] = 555  # 索引不存在，报错

      2. 切片

        list1 = [11, 20, 36, 33, 22, 10]
print(list1[0:5:2])  # [11, 36, 22]
print(list1[5:0:-2])  # [10, 33, 20]

      3. 长度

        len()

      4. 成员运算

        list1 = [111, 222, 333, 444]
print(111 in list1)  # True
print(555 not in list1)  # True

      5. 追加

        # append(object)
list1 = [111, 222]
list1.append(333)
list1.append(444)
print(list1)  # [111, 222, 333, 444]

      6. 插入

        # insert(index, object)
list1 = [111, 333]
list1.insert(1, 222)
print(list1)  # [111, 222, 333]

      7. 列表添加可迭代值的元素

        # extend(iterable)
list1 = [111, 222, 333]
list2 = [444, 555]
list1.extend(list2)
print(list1)  # [111, 222, 333, 444, 555]

      8. 删除

        list1 = [111, 222, 333]
del list1[0]  # 通用删除方法，没有返回值
print(list1)  # [222, 333]
list1 = [111, 222, 333]

# pop(index)  返回值为被删除的元素，不指定索引默认删最后一个元素
x = list1.pop(2)
print(list1)  # [111, 222]
print(x)  # 333

# remove(object)  无返回值，删除指定元素
list1 = [111, 222, 333]
x = list1.remove(111)
print(list1)  # [222, 333]
print(x)  # None

      9. 循环

        list1 = [111, 222, 333]
for item in list1:

    2. 需要掌握

      1. count()

        list1 = [10, 100, 10, 10, 1000]
print(list1.count(10))  # 3

      2. index()

        list1 = [101, 1002, 103, 104, 10005]
print(list1.index(103))  # 2,从左开始查找

      3. clear()

        # clear() 将整个列表的元素删除，留下空列表
list1 = [101, 1002, 103, 104, 10005]
list1.clear()
print(list1)  # []

      4. reverse()

        # reverse() 将列表元素倒置
list1 = [101, 1002, 103, 104, 10005]
list1.reverse()
print(list1)  # [10005, 104, 103, 1002, 101]

      5. sort()

        # sort(key, reverse) # 默认升序，当reverse为真，为降序 
list1 = [101, 1002, 103, 104, 10005]
list1.sort()
print(list1)  # [101, 103, 104, 1002, 10005]
list1 = [100, ‘a‘, 1000]
list1.sort()  # 不同类型混合，不可排序

    3. 了解

      1. 列表比大小，原理同字符串比大小

        # 对相应位置的元素为同种类型
list1 = [‘aaa‘, 123, 100]
list2 = [‘a‘, 100, 1000]
print(list2

    4. 补充（列表模拟）

      1. 队列

        • first in first out(FIFO)，先进先出
        list1 = []
# 入队操作
list1.append(100)
list1.append(200)
list1.append(300)
print(list1)  

# 出队操作，先进先出
print(list1.pop(0))
print(list1.pop(0))
print(list1.pop(0))

      2. 堆栈

        • last in fast out(LIFO)，后进先出
        list1 = []
# 入队操作
list1.append(100)
list1.append(200)
list1.append(300)
print(list1)  

# 出队操作，后进先出
print(list1.pop())
print(list1.pop())
print(list1.pop())

8.4 元组（不可变的列表）

  1. 作用：按照索引存放多个值，只能读，不能写

  2. 定义：tuple1 = () ()内用逗号分割开多个任意类型的元素

    • 元组中的索引值也是指向元素内存地址

    • 单独一个括号，只是包含，并不是元组

      tuple1 = (100)   # int
tuple1 = (100,)  # tuple

  3. 类型转换：tuple()

  4. 使用

    1. 优先掌握
      1. 按索引取值
      2. 切片
      3. 长度
      4. 成员运算
      5. 循环
    2. 需要掌握
      1. 寻找 index()
      2. 计数 count()
    3. 了解

8.5 字典

  1. 作用

  2. 定义：dict1 = {}，value可以是任意类型， key只能是不可变类型

    • # 可使用这种方式进行定义/类型转换
dict1 = dict(x=1, y=2, z=3)
print(d)  # {‘x‘: 1, ‘y‘: 2, ‘z‘: 3}
print(type(d))  # dict

# 也可使用这种方式创建字典（快速初始化），但value为相同值
Ages = [‘a‘, ‘b‘, ‘c‘]
dict1 = {}.fromkeys(Ages, 19)
print(dict1)

  3. 类型转换：dict()

    • # 可以使用这种方法
info = [
    [‘11‘, ‘22‘],
    [‘33‘, ‘44‘],
    [‘55‘, ‘66‘]
]

info = dict(info)
print(info)

  4. 使用

    1. 优先掌握

      1. 按key存取值

        dict1 = {‘a‘: 100, ‘b‘: 200}
print(dict1[‘a‘])  # 100
dict1[‘a‘] = 150  # 赋值
dict1[‘c‘] = 300  # 创建key
print(dict1)  # {‘a‘: 150, ‘b‘: 200, ‘c‘: 300}
# 创建字典时，若一个key出现若干次，则以最后一次出现的value为准

      2. 长度len

        # 若有若干个key相同，则该key只统计一次
dict1 = {‘a‘: 100, ‘b‘: 200, ‘a‘: 150, ‘b‘: 250}
print(len(dict1))  # 2

      3. 成员运算

      4. 删除

        # del
dict1 = {‘a‘: 100, ‘b‘: 200}
del dict1[‘a‘]
print(dict1)  # {‘b‘: 200}

# pop()    根据key删除
dict1 = {‘a‘: 100, ‘b‘: 200}
l = dict1.pop(‘a‘)
print(dict1)  # {‘b‘: 200}
print(l)  # 100    pop()返回删除的键值对的值

# popitem()    随机删除
dict1 = {‘a‘: 100, ‘b‘: 200}
l = dict1.pop(‘a‘)
print(dict1)
print(l)  # popitem()返回一个元组，包含删除的key和value

      5. keys()、values()、items()

        # keys()   	返回字典中所有的key组成的列表
# values()	返回字典中所有的value组成的列表
# items()	返回所有键值对组成的列表（每个键值对分别为子元组）

      6. fromkeys(）

        # fromkeys([key1, key2], value)  给字典中添加可迭代列表中的所有key，value均为fromkeys的第二个参数值，返回值为包含相应键值对的字典

# 但子列表中所有的key对应的value始终指向同一块地址
dict1 = {}
dict2 = dict1.fromkeys([‘a‘, ‘b‘], 100)
print(dict1)  # {}
print(dict2)  # {‘a‘: 100, ‘b‘: 100}

  5. 循环

    dict1 = {}
for key in dict1.keys():
    ...
for value in dict1.values():
    ...
for key, value in dict1.items():
    ...

  6. 需要掌握

    1. clear()

    2. update()

      dict1 = {‘a‘: 100, ‘b‘: 200}
dict2 = {"c": 100}
dict2.update(dict1)
print(dict2)  # {‘c‘: 100, ‘a‘: 100, ‘b‘: 200}
# 旧字典当中存在的key会被更新，旧字典当中不存在的key会由新字典追加

    3. setdefault()

      # setdefault(key, defalut)  defalut为默认的值,返回值为字典中该键对应的值

dict1 = {‘a‘: 100, ‘b‘: 200}
dict1.setdefault(‘b‘: 10000)  # 若原字典中有该键，则忽略其中的默认值，即不进行修改
dict1.setdefault(‘c‘: 10000)  # 若原字典中没有该键，则将该键添加到字典各种，并将默认值作为其值

print(dict1)  # {‘a‘: 100, ‘b‘: 200, ‘c‘: 10000}

    4. get() 容错性好

      # get(key)   返回key对应的value，若key不存在会返回None
dict1 = {‘a‘: 100, ‘b‘: 200}
print(dict1.get(‘a‘))  # 100
print(dict1.get(‘c‘))  # None

8.6 集合

  1. 作用

    1. 关系运算
      1. | 并集∪
      2. & 交集 ∩
      3. - 差集 返回前者独有的元素组成的集合
      4. ^ 对称差集 返回二者各自独有的元素组成的集合
      5. == / > /
    2. 去重（有局限性）
      1. 只能针对不可变类型
      2. 无法保证原来的顺序

  2. 定义 s = set(...)， s = set() 定义空集合

    • 在{}内用","分隔多个元素

    • 每个元素必须是不可变类型

    • 集合内没有重复的元素

    • 集合内元素无序

  3. 类型转换

    1. 元素为不可变类型
    2. 重复的元素只会保留一次
    3. 字典进行转换默认只保留key

  4. 使用

    1. 优先掌握

      1. intersection(s) ∩

      2. union(s) ∪

      3. difference(s) -

      4. symmetric_difference(s) ^

      5. issuperset(s) >=

      6. issubset(s)

      7. discard()

        # discard(args)

# 删除指定元素，若不存在该元素，do nothing

s = {100, 200, 300}
s.discard(100)
print(s)  # {200, 300}
s.discard(400)
print(s)  # {200, 300}

      8. remove()

        # remove(args)

# 删除指定元素，若不存在该元素，则会报错
s = {100, 200, 300}
s.discard(100)
print(s)  # {200, 300}
s.discard(400)
print(s)  # 报错

      9. update()

        # update(s)  将新集合中的元素加入旧集合，并去重

s = {100, 200, 300}
s1 = {150, 200, 300, 450}
s.update(s1)
print(s)  # {100, 200, 300, 150, 450}

    2. 需要掌握

      1. isdisjoint()

        # isdisjoint(s)  若两个集合交集为空，返回True，否则返回False

s = {100, 200, 300}
s1 = {150, 200, 300, 450}
print(s.isdisjoint(s1))  # False
s1 = {450, 150}
print(s.isdisjoint(s1))  # True

      2. pop()

      3. clear()

      4. add()

8.7 总结与分类

  1. 有序/无序
    1. 有序（序列类型）
      1. 列表
      2. 元组
    2. 无序
  2. 存一个值/存多个值
    1. 存一个值：原子类型
      1. 数字
      2. 字符串
    2. 存多个值：容器类型
      1. 列表
      2. 字典
      3. 集合
      4. （元组）
  3. 可变/不可变
    1. 可变
      1. 列表
      2. 字典
      3. 集合
    2. 不可变
      1. 数字
      2. 字符串
      3. 元组

9. 文件处理

9.1 字符编码

  • 人类与计算进行交互时，使用人类字符，而计算机只识别二进制数，因此字符必须翻译为二进制数

  • 翻译的过程中必须参照特定标准，称之为字符编码表，存放字符与二进制数的映射关系

  • unicode（内存使用的固定编码）

    • 兼容万国字符

    • 与万国字符编码都有对应关系

    • 采用16位二进制数对应一个中文字符串（个别生僻使用32、64位二进制数）

    • 老的字符编码都可以转化为unicode，但不能通过unicode互相转化

      ![](引用图像/批注 2020-08-24 000408.png)

  • utf-8(unicode translate format-8) 可以作为字符编码格式直接存入硬盘

    • 英文 -> 1Byte
    • 汉字 -> 3Byte
    • ...
9.1.1 编码与解码
9.1.1.1 编码
  • 由字符转化为内存中的unicode，以及由unicode转化成其他编码的过程，称为编码encode
9.1.1.2 解码
  • 由内存中的unicode转化成字符，以及由其他编码转化成unicode的过程，称为解码decode
9.1.1.3 编码解码
  • 编码
x = ‘上‘
x = x.encode(‘gbk‘)  # 将unicode转为gbk格式
print(x, type(x))  # b‘\xc9\xcf‘
  • 解码
x = b‘\xc9\xcf‘
x = x.decode(‘gbk‘)  # 按什么方式编码，则按什么方式解码
print(x, type(x))  # 上
9.1.2 如何保证不乱码

  • 编码格式应设置成支持文件内容字符的格式

  • 以什么编码格式存的就必须以什么编码格式取

  • 指定文件头，修改默认的编码，即存入硬盘时的编码格式

    • 在文件首行写

      # coding: xxx    如gbk，utf-8

    • python3默认为：utf-8

    • python2默认为：ASCII

  • python3的str类型默认直接存成unicode格式，不会乱码

  • 保证python2的str类型不乱码，需强制存为unicode格式

    str = u‘你好‘

  • python2有两种字符串类型

    • str
    • unicode
    str1 = ‘你好‘  ---->  str  # 字符串值会按照文件头指定的编码格式存入变量值的内存空间
str2 = u‘你好‘  ----> unicode
9.1.3 文件头

  • 设置文件头模板

    • File ---- Settings ---- File and Code Templates ---- Python Script

      ![](引用图像/批注 2020-09-01 125649.png)

9.2 文件处理

  • 什么是文件
    • 文件是操作系统提供给用户/应用程序操作硬盘的一种接口
  • 为何要用文件
    • 用户/应用程序可以通过文件将数据永久地保存在硬盘中，即操作文件就是操作硬盘
    • 用户/应用程序直接操作的都是文件，对文件进行的所有的操作，都是向操作系统发送系统调用，然后再由操作系统将其转换成具体的硬盘操作
  • 如何用文件
    • open()
9.2.1 文件处理基本流程

  1. 打开文件

    • open()功能的使用
  • 返回值为文件对象（句柄）
    - f = open(r‘文件路径‘, [模式(默认为rt)], [encoding=‘xxx‘])
    - r 指rawstring 原生字符串,也可不加"r"，将文件路径的"\"改为"/"
    - 类UNIX系统的默认encoding为utf-8，Windows默认为GBK
  1. 读/写文件
    • f.read(n) 从指针当前位置开始读，n表示读 n个字节，在t模式下指n个字符
    • f.write() 从指针当前位置开始写
  2. 关闭文件
    • f.close() 回收操作系统的资源
    • del f
9.2.2 资源回收与with语法

  • with：上下文管理

    # 在with的子代码运行结束后，自动执行f.close()
with open(‘a.txt‘) as f:
	res = f.read()
    print(res)
# 可打开多个文件
with open(‘a.txt‘) as f, open(‘b.txt‘) as f1:
    res = f.read()
    print(res)
    res1 = f1.read()
    print(res1)
9.2.3 操作模式
9.2.3.1 控制文件读写操作的模式

    上一篇：异常检测算法Local Outlier Factor(LOF)

    下一篇：SpringCloud 系列之 Consul

    文章来自：搜素材网的编程语言模块，转载请注明文章出处。
    文章标题：# Python基础
    文章链接：http://soscw.com/index.php/essay/61913.html

    评论

    亲，登录后才可以留言！

    热门文章

    推荐文章

    最新文章

    置顶文章

    关于我们 | 版权声明 | 常见问题 | 素材投稿 | 联系我们 | 网站地图 |
    搜素材网素材除本站原创外均由用户分享，若发现权利被侵害，请联系及时联系我们，我们会在第一时间进行处理。
    特别说明：本站所有资源除本站原创外仅供学习与参考，请勿用于商业用途,如有侵犯您的版权请联系客服服务QQ：点击这里给我发消息
    Copyright © 2024 soscw.com 搜素材网素材网版权所有 蜀ICP备18015633号-1