1.三种数据类型：整数型，浮点型，复数型

1.1 整数型

  • 十进制
  • 二进制：0b 或 0B 开头
  • 八进制：0o 或 0O 开头
  • 十六进制：0x 或 0X 开头

  • 转换为整数型：int()

    1.2 浮点型

  • 一般表示法：1324.0，-1324.0

  • 科学计数法：1.324e3,-1.324E-3

e或E 作为幂的符号

  • 转换为浮点型：float()

    1.3 复数型

  • 二元有序实数对（a，b）：a+bj

a 为实数部分，实部
b 为虚数部分，虚部

  • 获取实部：z.real
  • 获取虚部：z.imag
    • z 为一个复数，z= a+bj

      1.4 数字类型判断：type()

      1.5 数字转换为字符串：str()

      2. 数值运算操作

2.1 数值运算操作符

  1. x + y    #x 加 y
  2. x - y    #x 减 y
  3. x * y    #x 乘 y
  4. x / y    #x 除 y
  5. x // y    #x 整除 y
  6. x % y    #x，y的模运算，求余
  7. -x        #x的负值
  8. +x        #x本身
  9. x ** y    #x的y次幂

2.2 数值运算函数

  1. abs(x)        # x的绝对值
  2. divmod(x, y)# (x//y,x%y)，输出为二元组形式（元组类型）
  3. pow(x, y)    # x的y次幂 = x ** y
  4. round(x[,ndigits])    #对x四舍五入，保留ndigits位小数
  5. max(x)        #提取最大值
  6. min(x)        #提取最小值

3. 字符串类型操作

3.1 转义字符

  • 换行：\n
  • 反斜杠：\
  • 单引号：\’
  • 双引号：\”

  • 制表符：\t

    3.2 字符串索引

    image.png

  • <字符串或字符串变量>[序号]

    3.3 字符串切片

  • <字符串或字符串变量>[N:M]

从字符串中取 第N个 到 第M个字符，不包括M

  1. >>> a = "Hello World"
  2. >>> a[0]
  3. 'H'
  4. >>> a[-1]
  5. 'd'
  6. >>> a[0:5]
  7. 'Hello'
  8. >>> a[-5:-1]
  9. 'Worl'
  10. >>> a[-5:]
  11. 'World'

3.4 字符与变量值同时输出：format()

3.4.1 format()基本使用

  • <模板字符串>.format(<逗号分隔的参数>)

    • 模板字符串：由字符与 { }组成，控制显示效果
      1. a=input()
      2. print("{}说：我们终将走散。".format(a))

  • 出现多个参数

    • 按照出现顺序分别对应 .format() 中的不同参数
    • 在模板字符串中的 {} 中填入参数序号，从0开始，对应 .format() 中的第一个参数
      1. >>> a=input()
      2. H
      3. >>> b=input()
      4. W
      5. >>> print("{}ello {}orld".format(a,b))
      6. Hello World
      7. >>> print("{1}ello {0}orld".format(b,a))
      8. Hello World

      3.4.2 format()格式控制

      <模板字符串>.format(<逗号分隔的参数>)

  • 模板字符串格式控制 基本形式：

{<参数序号>:<格式控制标记>}

  • 格式控制标记内容： | <填充> | <对齐> | <宽度> | , | <.精度> | <类型> | | —- | —- | —- | —- | —- | —- | | 用于填充单个字符 | < 左对齐
    > 右对齐
    ^居中对齐 | 字符输出宽度 | 数字千分位分隔符 | 浮点数小数部分
    字符串最大输出长度 | 整数类型：
    b二进制，c，d十进制，o八进制，x小写十六进制，X大写十六进制
    浮点类型：
    e，E，f，%
    |

例：
>>>s = 阿美利卡
>>>p = 3.1415926
>>> print(“北美匪帮{:^25}，圆周率{:#>50}”.format(s,p),end=(“\n”))
北美匪帮**阿美利卡**，圆周率########################################3.1415926
>>>

3.5 字符串操作符

3.5.1 基本操作符

  • 连接两个字符串：x+y
  • 复制n次字符串x：xn 或 nx
  • 判断 x 是否是 s 的子串：x in s ，是则返回True，否则返回False

    3.5.2 字符串处理函数

    | len(x) | 返回字符串长度以及其他数据类型元素个数 | | —- | —- | | str(x) | 返回任意类型x所对应的字符串 | | chr(x) | 返回Unicode编码 x 所对应的单字符 | | hex(x) | 返回整数 x 的十六进制数 | | oct(x) | 返回整数 x 的八进制数 |

3.5.3 字符串处理方法

方法与函数一样，调用方式与函数不同，方法调用：.func(x)

  • 字符串分隔：.split()
  • 字符串小写：.lower()
  • 字符串大写：.upper()
  • 字符串替换：.replace()
  • 字符串统计：.count()

  • 字符串去除：.strip()

    • 除末尾元素：.rstrip()
    • 去除开头元素：.lstrip()

      4. 列表

      4.1 列表概念

  • 列表是又按照一定顺序排列的元素组成

    • 例如：学生名字列表

student_name = [“lihua”, “liufang”, “zhaoyun”, “gaohe”]
print(student_name)
print(student_name[2])
[‘lihua’, ‘liufang’, ‘zhaoyun’, ‘gaohe’]
zhaoyun

4.2 访问列表元素

  • <列表名>[元素顺序号]

元素顺序从[0]开始

  • 例如：student_name[2]

    1.   zhaoyun

    4.3 列表元素的修改、添加、删除

    4.3.1 元素修改

  • 修改与访问类似

<列表名>[元素顺序] = ‘新值’
student_name = [“lihua”, “liufang”, “zhaoyun”, “gaohe”]
print(student_name)
print(student_name[2])
student_name[2] = ‘wangyin’
print(student_name)

[‘lihua’, ‘liufang’, ‘zhaoyun’, ‘gaohe’]
zhaoyun
[‘lihua’, ‘liufang’, ‘wangyin’, ‘gaohe’]

4.3.2 元素添加

  • 末尾添加：使用方法 .append() 语句添加
    • <列表名>.append(‘添加值’)

  • 列表中插入：.insert()

    • <列表名>.insert(<元素序号>，’插入值’)

      4.3.3 元素删除

      1. del语句删除：知晓元素位置，删除元素

  • del <列表名>[元素序号]

    2. pop() 方法弹出元素：知晓元素位置，将元素从列表删除，并继续使用它的值，弹出

  • <变量名> = <列表名>.pop(元素序号)

将元素删除并将元素的值赋值给<变量名>

3. remove() 方法删除元素：不知元素位置，知晓该删除的值

  • <列表名>.remove(‘元素值’)

    4.4 列表的组织

    4.4.1 列表永久性排序：.sort()

  • <列表名>.sort()

    4.4.2 列表临时性排序：sorted()，保留原来的排列顺序，同时以特定顺序呈现它们

  • sorted(<列表名>)

    4.4.3 倒着打印列表：.reverse()，反转列表元素的排列顺序

  • <列表名>.reverse()

    4.4.4 计算列表长度：len()，计算列表元素个数

    5. 元组

    5.1 元组的定义

  • 由不可改变的值组成的列表被称为元组

  • 元组使用 () 来标识，列表用 [] 来标识

  • 元组中的元素不可改变，列表中的元素可以改变

    5.2 修改元组变量

  • 不能修改元组中的元素，但可以给存储元组的变量赋值；

  • 修改元组变量，可以重新定义整个元组

    6. 字典：可以存储任意对对象的可变容器

    6.1 字典定义格式

  • 字典的每个键与值的对应用冒号 ：隔开，每个键值对之间用逗号 ，分割，整个字典包括在大括号 {} 中：

例：
d = {key1 : value1 , key2 = value2 , key3 = value3}
注意：键 key 一般是唯一的，值不需要唯一

  • 创建一个空字典：<字典名> = {}

    6.2 访问字典

  • 输出键对应的值

    • <字典名>[<键>]

获取键 key1 对应的值：d[key1]

6.3 添加/修改键-值对

  • 添加键-值对
    • <字典名>[<新键名>] = <键值>

  • 修改键-值对

    • <字典名>[<键名>] = <新键值>

      6.4 遍历字典

      6.4.1 遍历字典所有 键-值对

  • for <键变量名，值变量名> in <字典名>.items():

  • 方法 .items() 使用：

    • <字典名>.items()
    • 返回的 键-值对 为只读类型，不可修改

      6.4.2 遍历字典所有 键/值

  • 遍历所有键：for <键变量名> in <字典名>.keys():

  • 遍历所有值：for <值变量名> in <字典名>.vlues():

  • 键是唯一的，值不需要唯一，所以值有重复项，为遍历创建不重复的 值列表，for循环中可加入 set() 函数

    • for <值变量名> in set(<字典名>.vlues() ):

      6.5 字典的嵌套

      6.5.1 字典列表

  • 先创建一个空列表

  • 后使用 for 循环创建一批 键-值对

    6.5.2 字典中存储列表

  • <字典名>={‘<键>’：[<列表值1>，<列表值2>，…，<列表值n>]}

  • 引用字典中的列表需要使用两次 for循环

for <键变量名>，<列表值变量名> in <字典名>.items():
for <值变量名> in <列表值变量名>：

6.5.3 字典中存储字典

  • 结构：

<外字典名1> =
{
‘<里字典名(键)>’：
{
‘<键1>’：’<值>’
‘<键2>’：’<值>’
}，
‘<里字典名(键)>’：
{
‘<键3>’：’<值>’
‘<键4>’：’<值>’
}
}

  • 输出：

for <里字典名键变量>，<值变量> in <外字典名1>.items():