让你的Python学习不再负担，而是软实力的体现（一）

Python 输入和输出

1.输出

Python 的输出函数

print() 函数

• 作用:

  向终端输出文字信息，在控制台输出打印数据，能让用户看到

  当有多个数据要输出时，中间用英文的逗号(,) 分隔开

• 调用格式

  print(数据1, 数据2, 数据3, ..., sep=' ', end='\n')
  示例:
  print("hello world!")
  print("我们班有多少人": 12)
  print(1, 2, 3, 4, sep=" ", end="\n")

  在python中主要使用print实现输出，print是一个函数

  在python中函数调用需要添加()，括号内是传给函数的参数

  2.输入

Python的基本输入函数 input 函数

• 作用

  是个阻塞函数，让程序停下来，等待用户输入文字信息，返回用户输入文字的 字符串

• 调用格式

  input("提示信息")
  示例：
  name = input('请输入您的姓名:')

  python中，通过input函数获取用户键盘输入

  input函数的参数是字符串，它是屏幕提示语

Python注释

在 Python 中，注释不会影响程序的执行，但是会使代码更易于阅读和理解。

Python 中的注释有单行注释和多行注释。井号 (#)

多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，

示例:

# 这是一个注释print("Hello, World!")
'''这是多行注释，用三个单引号这是多行注释，用三个单引号 这是多行注释，用三个单引号'''
print("Hello, World!")
"""这是多行注释，用三个双引号这是多行注释，用三个双引号 这是多行注释，用三个双引号""

Python变量

1.赋值语句

• 作用

  变量是代数的思想，用来代替或缓存数据,可以让程序更加简洁

  创建一个自定义名字的变量，此变量可以用于绑定数字类型或者表达式执行的结果，供后续使用

• 语法

变量名 = 数字类型
变量名 = 表达式
变量名1 = 变量名2 = 变量名3  = 数字类型
变量名1, 变量名2, 变量名3  = 数字类型1, 数字类型2, 数字类型3

示例

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "hqyj"     # 字符串

说明

1. 第一次为变量赋值，python 会创建变量，同时绑定表达式执行的结果

2. 第二次或者以后为变量赋值，会改变原有变量的绑定关系

3. python 的变量没有类型，它绑定的对象才有类型

4. 变量在使用之前，必须先进行赋值

5. 变量赋值是一个自右向左的运算，将=右边表达式的计算结果，赋值给左边的变量

2.变量

变量是在python 内用赋值语句创建，用来绑定一个数据的有名对象

• 变量名

  变量名必须是一个标识符

• 标识符的命名规则

  1. 第一个字母必须是英文字母[A-Z a-z]或下划线 [ _ ]，所以数字不能开头

  2. 从第二个字母起(如果有)，必须是英文字母、下划线、数字

     [ A-Z、a-z、 0-9、 _ ]

     变量名称约定

  3. 变量名区分大小写

• 示例

  以下是合法的标识符

a        a1           abc       ABC     a1b2c3d4
one_hundred          count      _a      __ABC__
​
getNameAge         get_name_age        GetNameAge
# 小驼峰              匈牙利命名法         大驼峰

• python 编程语言中的关键字不能作为标识符

• 推荐采用的命名方法

  • 变量名全部采用小写字母，如pythonstring

  • 简短、有意义，如pystr

  • 多个单词间用下划线分隔，如py_str

  • 变量名用名词，函数名用谓词（动词+名词），如 phone / update_phone

  • 类名采用驼峰形式，如MyClass

• 关键字(keywords)

  • 计算机编程语言中保留的标识符称为关键字, 关键字不能当成变量名使用

  关键字通常用于语法标识

  • python中的部分关键字

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

• 注意：

1. 避免使用单个字母或不明确的缩写作为变量名，除非是在特定上下文中广泛使用的约定，如循环变量 i。

2. 合理使用命名空间：避免定义与Python内置函数或常用模块的名称相同的变量，以防止命名冲突。

3. 模块级别的变量可以使用大写字母，表示为常量，例如 PI = 3.14159。

3.变量类型

基础类型（内置类型）

字符串

说明

• 双引号的字符串的内部的单引号不算是结束符

• 单引号的字符串的内部的双引号不算是结束符

字符串的转义

字符串的字面值中，可以用反斜杠 \ 后加一个或多个字符串，代表一个单个的字符

\'    代表一个单引号
\"    代表一个双引号
\n    代表一个换行符
\\    代表一个反斜杠

字符串运算

• 字符串连接：+；

  • 字符串的基本运算

    + 号运算符, 用于拼接字符串(生成新的字符串)

    + 号的两侧都必须是字符串

    '今天是' + '7月13日'  # 生成 '今天是7月13日'
    s1 = '123'
    s2 = "456"
    s3 = s1 + s2
    print(s1)   # 123
    print(s2)   # 456
    print(s3)   # 123456

字符串的切片 slice

• 作用

  从字符串序列中取出相应位置的元素，重新组成一个新的字符串

• 语法

  字符串[(开始索引b):(结束索引e)(:(步长s))]

  注: () 括起来的内容代表可以省略

• 说明

  • 开始索引b是切片切下的开始位置

  • 结束索引e 是切片的终止位置(但不包含终止点)

  • 步长是切片取出数据后向后移动的方向和偏移量

    • 没有步长，相当于步长为1(默认为1)

    • 当步长为正数时，取正向切片

      • 开始索引默认为0, 结束索引是最后一个元素的下一个索引

    • 当步长为负数时，取反向切片

      • 开始索引默认为-1, 结束索引是第一个元素的前一个索引

示例

     #   01234
>>> s = 'ABCDE'
>>> s[1:]    # 'BCDE'
>>> s[-2:]   # 'DE'
>>> s[1:4]   # 'BCD'
>>> s[:]     # 'ABCDE'
>>> s[:2]    # 'AB'

字符串的格式化表达式

占位符

• 作用

  生成具有一定格式的字符串

• 语法规则

  格式化字符串 % 参数1
  # 或者
  格式化字符串 % (参数1, 参数2, 参数3)

  其他字符串

  • 字节串（bytes）：表示二进制数据，以字节为单位，例如b'hello'。

  • 空值（NoneType）：表示一个特殊的空值，通常用于表示缺失或未定义的值。

  使用type函数可以获取一个变量或值的类型。

数字

• Python 中的基本的数字类型

  • 整数 int

  • 浮点数(小数) float

  • 布尔类型数 bool

整数 int

整数的字面值

## 十进制的写法
100        0         -5

## 二进制的写法 0b 开头 后跟 0~1
0b1101

## 八进制的写法 0o开头 后跟 0~7
0o777   等于  0b111111111   等于 511

## 十六进制的写法  0x 开头 后跟 0~9, a-f, A-F
0xA1B2C3D4

浮点数(小数) float

浮点数的字面值

## 小数写法
3.14         0.14       .14         3.0       3.      0.0
## 科学计数法
6.18E-1   # 等同于 0.618   
2.9979E8   # 等同于 299790000.0

布尔类型的数 bool

• True 真(表示行，好，成立) 值为1

• False 假(表示不行，不好，不成立) 值为0

引用类型（复合类型）

• 列表（list）：可变序列，用于存储一组值，可以包含不同类型的元素。

• 元组（tuple）：不可变序列，用于存储一组值，元素不能被修改。

• 字典（dict）：键值对映射，用于存储关联性数据，由键和对应的值组成。

• 集合（set）：无序集合，用于存储唯一的元素，不允许重复。

• 枚举类型（Enum）：本质上是一个类，它是标准库中的enum模块提供的一个功能，用于创建有限的、命名的枚举类型

• 自定义类（class）：创建自定义类来表示复杂的数据结构，具有自定义属性和方法。

按照是否可以修改划分:

• 不可变数据：Number（数字）、String（字符串）、Tuple（元组）

• 可变数据：List（列表）、Dictionary（字典）、Set（集合）

---

4. del删除变量

可以通过使用del语句删除单个或多个对象的引用

Python 数字操作

Python 数字数据类型用于存储数值。

数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。

1.Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为十进制整数

• float(x) 将x转换到一个浮点数。

• bin(x)将x转换为二进制

• oct(x)将x转换为八进制

• hex(x)将x转换为十六进制

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字.

• bool(x)将 x 转化为布尔值

2.Python 运算符

a). 算术运算符

• +：加法

• -：减法

• *：乘法

• /：除法

• %：取模（取余数）

• **：幂运算

• //：整除（向下取整数部分）

b). 比较运算符

• ==：等于

• !=：不等于

• <：小于

• >：大于

• <=：小于等于

• >=：大于等于

c). 逻辑运算符

• and：与（逻辑与）

• or：或（逻辑或）

• not：非（逻辑非）

d). 位运算符

Python中的位运算符主要用于处理整数类型的二进制位操作。以下是Python中的6种主要位运算符：

• &：按位与

• |：按位或

• ^：按位异或

• ~：按位取反

• <<：左移位

• >>：右移位

e). 赋值运算符

• =：赋值

• +=：加法赋值

• -=：减法赋值

• *=：乘法赋值

• /=：除法赋值

• %=：取余赋值

• **=：幂运算赋值

• //=：整除赋值

3.数学函数

部分函数是python环境自带的,部分是math模块带的,部分是公共的

先引入math模块:

import math

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
math.ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
math.exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
math.fabs(x)	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
math.floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
math.log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
math.log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
math.modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
math.pow(x, y)	x**y 运算后的值。
round(x ,n)	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。 1.保留整数只有一个小数时:4舍6入5看齐,奇进偶不进 2.保留整数或小数超过一个小数时:看保留位的下下位是否存在
math.sqrt(x)	返回数字x的平方根。

4.随机数

先引入random库基础库:

import random

函数	描述
random.choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random.randrange (start, stop,step)	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random.random()	随机生成下一个实数，它在[0,1)范围内。
random.shuffle(list)	将序列的所有元素随机排序,修改原list
uniform(x, y)	随机生成实数，它在[x,y]范围内.

5.三角函数

先引入math库基础库:

import math

函数	描述
math.acos(x)	返回x的反余弦弧度值。
math.asin(x)	返回x的反正弦弧度值。
math.atan(x)	返回x的反正切弧度值。
math.atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
math.cos(x)	返回x的弧度的余弦值。
math.sin(x)	返回的x弧度的正弦值。
math.tan(x)	返回x弧度的正切值。
math.degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
math.radians(x)	将角度转换为弧度

6.数学常量

先引入math库基础库:

import math

常量	描述
math.pi	数学常量 pi（圆周率，一般以π来表示）
math.e	数学常量 e，e即自然常数（自然常数）。

条件语句

1.if

if condition:

# 当条件为真时执行这里的代码,否则不执行这里

2.if-else

if condition:

# 当条件为真时执行这里的代码

else:

# 如果前面的条件都为假，执行这里的代码

3.if-elif-else

if condition:

# 当条件为真时执行这里的代码

elif another_condition:

# 当上面条件为假，而这个条件为真时执行这里的代码

else:

# 如果前面的条件都为假，执行这里的代码

4.整体

• 语法

  if 条件表达式1:
      语句块1
  elif 条件表达式2:
      语句块2
  elif 条件表达式3:
      语句块3
  ...
  elif 条件表达式n:
      语句块n
  else:
      语句块(其他)
      

  • 说明

    • elif 子句可以有0个，1个或多个,

    • else 子句可以有0个或1个且只能放在最后

    • 它通过对表达式逐个求值直至找到一个真值在子句体中选择唯一匹配的一个；然后执行该子句体（而且 if 语句的其他部分不会被执行或求值）。 如果所有表达式均为假值，则如果 else 子句体如果存在就会被执行。

循环语句

while 语句

• 作用

  根据一定的条件，重复的执行某个语句块

• 语法

  while 真值表达式:
      语句块1  (*此部分可能会重复执行)
  else:
      语句块2

• 说明

  • else 子句可以省略

  • else 子句 当且仅当 真值表达式为假Flase的时候 会执行 else 里的语句块2

  • 如果 此 while 是因为 调用 break 语句而终止循环。则 else 子句里的语句不会执行

语句嵌套

• while 语句也是语句, 和其他的语句一样，可以嵌套到其他的任何复合语句中。外层控制行，内层控制列。

• while 语句嵌套示意:

  while 真值表达式:
      ...
      while 真值表达式2:
          ...
      else:
          ...
      ......
  else:
      ...

  break 语句

  • 作用

    用于循环语句(while, for语句)中, 当break 执行是，她会终止包含他的当前循环。

  • 语法

    break

  • 说明

    • break 语句只能用在 while 语句或for语句的内部。

    • break 语句通常和 if 语句组合使用。

    • 当break 语句执行后，此循环语句break 之后的所有语句都不会执行（else 子句里的语句也不执行）

    • break 语句只能终止包含他的当前循环，当有循环嵌套时，只能跳出离他最近的一个循环

    死循环

    death loop

    • 死循环是指循环条件一直成立的循环

    • 死循环通常使用 break 语句来终止循环

    • 死循环的 else 子句中的语句永远不会执行

    写法

    while True:
        语句块

    死循环通常用户循环次数无法确定的循环

for 语句

• 作用

  • 用来遍历可迭代对象的数据元素

  遍历是指经历且只经历一遍

  可迭代对象是指能够依次获取数据元素的对象

  可迭代对象

  1. 字符串

  2. ---- 以下后面才讲----

  3. 列表 list

  4. 字典 dict

  5. ...

• 语法

  for 变量列表 in 可迭代对象:
      语句块1
  else:
      语句块2

• 语法说明

  • else 子句可以省略

  • else 子句的语句块2 只有在 可迭代对象不再能提供数据的时候才会执行

  • 因为 语句块1 部分调用break 而终止循环式，else 子句部分不会执行。

range 函数

• 作用

  用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器）

• 调用格式

  range(stop)                 # stop 停止整数
  range(start, stop)          # start 开始整数
  range(start, stop, step)    # step 步长

  range 函数调用会生成从 start 开始，到 stop 结束(不包含stop) 的一系列整数，整数的间隔 step

  start 默认值为0, step 默认值为1

continue 语句

• 作用

  用于循环语句(while 语句和for语句)中， 不再执行本次循环内 continue 之后的语句，开始一次新的循环

• 语法

  continue

• 说明

  • 在for 语句中, 执行continue 语句，for语句将会从可迭代对象向中获取下一个元素绑定变量后再次进行循环

  • 在while 中,执行continue 语句, 将会直接跳转到while 语句的真值表达式处，重新判断循环条件。

pass 语句

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句

容器

python 中默认有4种可变的容器

1. 列表list

2. 字典 dict

3. 集合 set

4. 字节数组 bytearray

容器都是可迭代对象, 可以用for 语句来遍历容器

Python列表(list)

Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表 ，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

• 列表是一种可以存储任意个各种类型的序列容器

• 列表内的数据有先后顺序关系

• 列表是可变的容器

1.列表的创建

• 创建列表的字面值

  >>> L = []     # 创建一个空的列表
  >>> L = ['北京', '上海', '广州', '西安']  # 创建一个含有4个字符串的列表
  >>> L = [1, 'Two', 3.14, True, False, None]
  >>> L = [1, 2, [3.1, 3.2], 4]   #  含有四个元素的列表，第三个元素是列表
  >>> L2 = [
  	['姓名','语文成绩','数学成绩'],
  	['小王', 90, 100],
  	['牛犇', 59, 26]
  

  注： python 中的 (), [], {} 和 三引号字符串都要成对出现, 可以换行

• 创建列表的构造函数 list

  list()           # 创建一个空的列表，等同于 []
  list(可迭代对象)   # 用可迭代对象创建一个列表

列表的运算

列表list同字符串str都是序列, 他们的运算规则基本相同

访问列表中的值

2.1 索引

列表[整数表达式]

2.2 反向索引

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

2.3 切片

列表[(开始索引b):(终止索引e)(: (步长s))]

() 里的内容代表可以省略

列表是可变的容器(不同于字符串)

列表是可变的

字符串是不可变的

3.列表的数据操作(增、删、改、查)

3.1 添加数据（增）

• 方法

方法名(L代表列表)	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象

3.2 修改数据 (改)

• 用索引赋值可以改变列表内的数据

列表[整数表达式] = 表达式

3.3 删除数据 (删)

• 方法

  方法	说明
  L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
  L.clear()	清空列表

  del 语句删除指定位置的数据元素

  • 语法

    del 变量名     # 删除变量，同时解除变量绑定的对象
    del 列表[整数表达式]

3.4 查看(索引取值就是查看)

列表的数据操作(增、删、改、查)

• 添加数据

  • 方法

  方法名(L代表列表)	说明
  L.append(x)	向列表的末尾追加单个数据
  L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
  L.extend(可迭代对象)	等同于: L += 可迭代对象

  修改数据(改)

  • 用索引赋值可以改变列表内的数据

  列表[整数表达式] = 表达式

删除数据(删)

• 方法

  方法	说明
  L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
  L.clear()	清空列表

del 语句删除指定位置的数据元素

• 语法

  del 变量名     # 删除变量，同时解除变量绑定的对象
  del 列表[整数表达式]

  4.嵌套列表

  使用嵌套列表即在列表里创建其它列表

  a = ['a', 'b', 'c']
  n = [1, 2, 3]
  x = [a, n]
  print(x)#[['a', 'b', 'c'], [1, 2, 3]]
  print(x[0])#['a', 'b', 'c']
  print(x[0][1])#b

  5.Python列表常用API

  操作列表的函数

  序号	函数
  1	len(list)列表元素个数
  2	max(list)返回列表元素最大值
  3	min(list)返回列表元素最小值
  4	list(seq)将元组转换为列表

  列表的常用方法

  运算	结果
  s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
  s.count(x)	x 在 s 中出现的总次数
  s.append(x)	将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
  s.clear()	从 s 中移除所有项 (等同于 del s[:])
  s.copy()	创建 s 的浅拷贝 (等同于 s[:])
  s.extend(t) 或 s += t	用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
  s.insert(i, x)	在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
  s.pop([i])	提取在 i 位置上的项，并将其从 s 中移除
  s.remove(x)	删除 s 中第一个 s[i] 等于 x 的项目。
  s.reverse()	就地将列表中的元素逆序。
  s.sort( key=None, *reverse=False*)	对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序

Python元组(tuple)

• 元组是不可改变的列表

• 同列表list 一样，元组可以存放任意类型的数据

• 但是，一旦创建将不可修改

• 元组使用小括号 ( )，列表使用方括号 [ ]

1.元组的创建

创建元组的字面值

用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组

t = ()         # 空元组
t = (100,)     # 含有一个数据元素的元组
t = 100,       # 含有一个数据元素的元组，元组中只包含一个元素时，需要在元素后面添加逗号 ，否则括号会被当作运算符使用
t = (1, 2, 3)  # 含有三个数据元素的元组
t = ( 'hqyj', 2004) # 存放不同类型的元组
t = 1, 2, 3    # 含有三个数据元素的元组

type(x) 函数用来返回数据x的类型

创建元组的函数 tuple

t = tuple()          # t = ()
t = tuple(range(5))  # t = (0, 1, 2, 3, 4)

2.元组的数据操作（删，查，运算）

2.1 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)#name 'tup' is not defined

2.2 查看元组

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)

2.3 元组的运算

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz') 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

>>> t = (1, 2, 3) + (4, 5, 6)
>>> t += (7, 8, 9)  # 等同于 t = t + (7, 8, 9)
>>> t = t * 2
>>> t *= 2
>>> 5 in t
True

3.元组不可变

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup)#报错'tuple' object does not support item assignment

元组常用API

Python元组包含了以下内置函数

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。

元组常用的方法

运算	结果
s.index(x[, i[, j]])	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
s.count(x)	x 在 s 中出现的总次数

Python字典(dict )

• 字典是一种可变容器模型，且可存储任意类型对象。

• 字典的数据都是以键(key)-值(value)对的形式进行映射存储.

• 字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中

• d = {key1 : value1, key2 : value2, key3 : value3 }

• 字典的数据是无序的

• 字典的键不能重复，且只能用不可变类型作为字典的键

• 字典中的数据只能用"键"key 进行索引，不能用整数进行索引

  1.字典的创建

  • 创建字典的字面值:

  字典的表示方式以 {} 括起来， 以英文的冒号 (:) 分隔键值对，各键值对之间用逗号(,)分隔

  d = {}    # 创建空字典
  d = {'name': "weimingze", "age": 35}
  d = {'a': [1, 2, 3]}

  以下写法会存在问题

  • 键必须是唯一的，但值则不必。

  • 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

  d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2}  
  d = {[1, 2, 3]: 'a'}          # 不能用可变类型作为字典的键  # 报错

  • 字典的创建函数 dict（）

2.2 访问字典里的值

• 字典的键索引

  • 语法

  字典[键key]

  用键索引可以查看字典中的数据

2.3 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作

显式删除一个字典用del命令

• 语法

del 字典[键]

3.字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (mydic['Name'])

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行

mydic1 = {97:"a",98:"b"}
mydic2 = {"name":"karen","age":27}
mydic3 = {['Name']: 'karen', 'Age': 27}
print(mydic3[['Name']])#报错unhashable type: 'list'

注: python 中有四种可变类型

1. 列表 list

2. 字典dict

3. 集合 set

4. 字节数组 bytearray

   字典是可迭代对象, 字典只能对所有的键进行迭代访问

4.字典常用API

操作字典的函数：

序号	函数	描述
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，可以打印的字符串表示。
3	type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

字典的方法：

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
3	dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
8	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()返回并删除字典中的最后一对键和值。

5.列表、元组、字典小结

1. 列表和元组是有序的，字典的存储是无序的

2. 列表、字典是可变的,元组是不可变的

3. 字典的键索引速度快，列表的索引速度也快

4.列表和元组是顺序存储的，字典是散列存储的

5.字典的 in / not in 运算符快于列表的 in / not in 运算符

集合set/ 固定集合 frozenset

• 集合是可变的容器，固定集合是不可变的集合

• 集合相当于只有键没有值的字典

• 集合是无序的不重复元素的存储结构

• 集合内的数据都是唯一的，不可变的

1.集合的创建

• 创建集合的方式

  空集合 set()

  非空集合 用 {} 括起来，值用逗号分隔开

2.集合的数据操作（增、删）

2.1 添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x ) 添加元素到集合

s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开

2.2 删除元素

s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x ))：将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

s.pop())：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3.集合内置方法常用API

集合的方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

容器总结

• 容器总结

  • 类型

    • 列表 list

    • 元组 tuple

    • 字典 dict

    • 集合 set / 固定集合 frozenset

  • 可变和不可变

    • 可变的容器

    list   dict    set       

    • 不可变得容器

    tuple, frozenset

  • 有序和乱序

    • 有序

      list   tuple   

    • 无序

      dict    set    frozenset