Python的基本数据类型:

01. 数字:整型(int)，浮点型(float)，复数(complex):

释义:

不可变类型

一旦创建,不可修改

不是可迭代对象

原子型

01. 整型数 int:

整型数是不带有小数部分的数字, 包括自然数, 0及负数自然数

如: -2, 100, 0

int():

把字符串转换成数字，base指定以多少进制来转换, 默认以十进制转换

int('f', base=16) # 15

int('af', base=16) # 10 * 16 + 15 -->175

int('v', base=32) # 31

int('av', base=32) # 10 * 32 + 31 -->351

bit_length():

当前数字的二进制至少用几位来表示

int(10).bit_length() # 10的二进制表示是1010 长度是4

整数字面值的表示方式:

01. 十进制方式表示：

-10

0

99999999999999999

02. 八进制的表示方式(0o开头，后跟0~7):

0o177 (127)

0o11 (9)

03. 十六进制的表示方式(0x开头，后跟0~9,A~F,a~f):

0x11 (17)

0xFF (255)

0x1234ABCD

04. 二进制表示方式 (0b开头，后跟0~1):

0b1001

02. 浮点型数 float:

浮点数是带有小数部分的数字（小数部分也可以是0)

浮点数的两种表示方式:

01. 小数表示:

3.14

3.1

3.0

3.

0.14

.14

02. 科学计数法格式:

小数 e/E(正负号) 指数

6.18E-1

2.9979e8

03. 复数 complex

分为两部分:

实部(real)

虚部(image)

注：虚部必须是以j或J结尾的数

复数字面值的表示方式:

1j

(2j)

1+1j

1-1j

(-100+100j)

02. 布尔值(bool):

用来表示真的假两种状态的类型:

True 表示真(条件满足或成立)

False 表示假(条件不满足或不成立)

说明：

True 值为1 # 非0为真

False 值为0 # 0为假

bool(x) 返回False的情况:

None 空值

0 int() 空整数

0.0 float() 空浮点数

0j complex() 空复数

'' str() 空字符串

() tuple() 空元组

[] list() 空列表

{} dict() 空字典

set() 空集合

03. 字符串(str):

释义:

用引号括起来的部分都是字符串, 用来记录文本信息

字符串是不可变类型一但创建，不可修改

一旦修改或者拼接，都会生成新的字符串

是一种序列, 即可迭代对象

原子型

01. 字符串转换的常用函数:

hex(i) 将整数i装换成十六进制的字符串 # hex(10) # '0xa'

oct(i) 将整数i装换成八进制的字符串 # oct(10) # '0o12'

bin(i) 将整数i装换成二进制的字符串 # bin(10) # '0b1010'

ord() 根据字符串,返回一个字符串Unicode值,注意字符串只能有一个字符 # ord('a') # 97

chr() 根据Unicode值,返回一个对对应的字符 # chr(97) # 'a'

str() 字符串构造函数将对象转换成字符串 # str(10) # '10'

02. 引号的使用:

Python提倡使用单引号

单引号内掉双引号不算结束符

双引号内掉单引号不算结束符

三引号内可以包含单引号和双引号

三引号字符串中的换行会自动转换为换行符'\n'

03. 空字符串表示方法:

s = '' 单引号

s = "" 双引号

s = '''''' 三单引号

s = """""" 三双引号

s = str() 创建一个空字符串

04. 非空字符串的字面值表示方式:

s = 'hello'

s = "hello"

s = '''hello'''

s = """hello"""

s = str(list(x for x in range(10))) # s = '[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'

05. 隐式字符串拼接:

s = "I'm a programmer." 'My name is "coco"'

print(s) # I'm a programmer.My name is "coco"

s2 = 'aaa' "bbb" '''ccc''' """ddd"""

print(s2) # aaabbbcccddd

06. 用转义序列代表特殊的字符:

字符串字面值中 用字符反斜杠\ 后跟一些字符代表特殊的一个字符

字符串中反斜杠转义字符表:

\' 单引号

\" 双引号

\\ 反斜杠

\n 换行

\r 返回光标至行首

\f 换页

\t 水平制表符

\v 垂直制表符

\b 退格

\0 字符串, 字符值为零

\xXX XX 为两位十六进制表示的字符

\uXXXX Unicode16 的十六进制表示的字符

\UXXXXXXXX Unicode32的十六进制表示的字符

07. 字符串中常见的ASCII编码:

字符 十进制 十六进制

'0' 48 0x30

'A' 65 0x41

'a' 97 0x61

'\0' 0 0x00

'\n' 10 0x0A

08. 字符串与Unicode编码(国标码):

字符串保存的是Unicode编码值,Unicode的前128编码个和ASCII编码一致

全世界字符统一编码

分类:

UNICODE16(两个字节)

UNICODE32(四个字节)

示例：

>>> print('\u9042')

遂

>>> print('遂')

遂

>>> print('\U00009042')

遂

09. raw 字符串(原始字符串):

格式:

r'字符串内容'

r"字符串内容"

r'''字符串内容'''

r"""字符串内容"""

作用：

让转义符号 \ 无效

示例:

# 转义之后的

a = 'C:\newfile\test.py'

print(a)

# 未转义raw字符串

a = r'C:\newfile\test.py'

print(a)

10. 字符串的运算:

+ 加号运算符用于拼接字符串

+= 运算符用原字符串与右侧字符串拼接生成新的字符串

示例：

s = 'ABCD' + 'EFG'

s += '123'

print(s) # ABCDEFG123

s2 = s + s

print(s2) # ABCDEFG123ABCDEFG123

* 生成重复的字符串

*= 生成重复的字符串并让原变量绑定生成后的字符串

示例：

s = "ABC" * 3 # s='ABCABCABC'

print(s)

s2 = 5 * '0' # s3 = '00000'

s = "123"

11. 字符串的比较运算:

>

>=

<

<=

==

!=

格式:

x > y

比较规则：

01. 字符串x的第一个字母与字符串y的第一个字母比较,如果不相同,则直接得到比较结果,如果相同,则再取第二个字母进行比较,以此类推

02. 比较的依据是字符的UNICODE编码值 例如 "A" < "B" ==> 0x41 < 0x42 True

03. 有值大于没有值 例如 "ab" > "a" ==> True

示例:

'AD' > 'ABC' # True

'ABC' != 'CBA' # True

'ABC' == 'CBA' # False

'AB' <= 'ABC' # True

12. in / not in 运算符:

作用：

用于序列，字典，集合等容器中，用于判断某个值是否存在于容器中,如果存在返回True,否则返回False

not in 与 in 运算符的返回结果相反

格式:

对象 in 序列

示例：

>>> 'A' in "ABCD"

True

>>> x = 'welcome to tarena'

>>> 'to' in x

True

>>> 'hello' not in x

True

>>> "ABCD" in x

False

13. 字符串的索引 index:

python的字符串是不可以改变的字符序列

语法：

字符串[整数表达式]

说明：

python序列都可以用索引(index)来访问序列中的对象

python序列的正向索引是从0开始的，第二个索引为1 ..., 以此类推，最后一个索引是len(s)-1

python序列的反向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，以此类推．第一个是-len(s)

示例：

>>> s = "ABCD"

>>> print(s[0]) # A

A

>>> print(s[2]) # C

C

>>> print(s[-1]) # D

D

>>> print(s[-4]) # A

A

>>> print(s[-8]) # 出错

14. 切片 slice:

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

语法:

字符串[(开始索引begin):(结束索引end)(:(步长step))]

顾头不顾尾, 从begin开始截取, 截取到end位置, 但不包括end

注: 小括号() 括起的部分代表可以省略

语法说明：

01. 开始索引是切片切下的位置,0代表第一个元素,1代表第二个元素,-1 代表最后一个元素

02. 结束索引是切片的终止索引（但不包含终止点）

03. 步长是切片每次获取完当前元素后移动的方向和偏移量

04. 没有步长，相当于取值完毕后向右移动一个索引的位置（默认为1)

05. 当步长为正整数时，最正向切片

06. 当步长的负整数时，取反向切片, 默认的起始位置为最后一个元素，终止位置是第一个元素的前一个位置

示例:

s = 'ABCDE'

s[2:-2] # 'C'

s[:-2] # 'ABC'

s[:-2:2] # 'AC'

s[-1:0:-1] # 'EDCB'

s[-1:-100:-2] # 'ECA'

s[::-2] # 'ECA'

s[::-1] # 'EDCBA'-->字符串的翻转(逆序)

15. 字符串格式化表达式(%):

作用：

生成一定格式的字符串, 运算符 %

语法格式:

格式化字符串 % 参数值

格式化字符串 % (参数值1, 参数值2, ...)

示例:

fmt = "姓名: %s, 年龄: %d"

name = "张飞"

age = 20

print(fmt % (name, age))

()传值:

s2 = "i am %(name)s , age %(age)d" % {"name": "coco", "age": 18}

print(s2) # i am coco , age 18

sep=打印拼接:

print("root", "x", "0", "0", sep=":") # root:x:0:0

16. 占位符 % 和类型码之间的格式语法:

% [格式语法] 类型码(d,s,f等)

格式语法:

- 左对齐

+ 显示正负号

0 补零

宽度

宽度.精度

示例:

"%10d" % 123 # ' 123'

"%-10d" % 123 # '123 '

"%10s" % "abc" # ' abc'

"%-5s" % 'abc' # 'abc '

"%+10d" % 123 # ' +123'

"%010d" % 123 # '0000000123'

"%.2f" % 3.1415926535897932 # '3.14'

"%7.2f" % 3.1415926535897932 # ' 3.14'

深坑注意:

过于复杂的格式化字符串可以放在外部格式化后再引用

示例:

temp_list = ['111', '4444', '33']

length = max(len(i) for i in temp_list)

temp_str = "%" + str(length) + "s"

# for i in range(len(temp_list)): print("%" + str(length) + "s" % temp_list[i]) # 会报错

for i in range(len(temp_list)):

print(temp_str % temp_list[i])

打印效果:

' 111'

'4444'

' 33'

17. 字符串文本解析方法 split 和 join:

作用:

S.split(sep=None) 将字符串使用sep作为分隔符分割S字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符分割

S.join(iterable) 用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串

示例：

s = 'Beijing is capital'

L = s.split(' ') # L = ['Beijing', 'is', 'capital']

L = ["C:", "Programe files", "Python3"]

s = '\\'.join(L) # s = "C:\\Programe files\\Python3"

18. 格式化字符串 format:

s = 'i am {}, age {}'.format('coco', 18)

print(s) # 'i am coco, age 18'

s = 'i am {1}, age {0}'.format('coco', 18)

print(s) # 'i am 18, age coco'

s = 'i am {name}, age {age}'.format(name='coco', age=18)

print(s) # 'i am coco, age 18'

s = 'i am {name}, age {age}'.format(**{'name': 'name', 'age': 18})

print(s) # 'i am coco, age 18'

s = 'i am {0[1]}, age {1[0]}'.format([0, 1], ['a', 'b'])

print(s) # i am 1 , age a

s = 'i am {:s}, age {:d} {:.2f}'.format('aa', 10, 3.14)

print(s) # 'i am aa, age 10 3.14'

s = 'i am {:s}, age {:d} {:.2f}'.format(*['aa', 10, 3.14])

print(s) # 'i am aa, age 10 3.14'

s = 'i am {name:s}, age {age:d}'.format(name='coco', age=18)

print(s) # 'i am coco, age 18'

# b:二进制, o:八进制, d:十进制, x:小写十六进制, X:大写十六进制, .2%:百分比保留2位小数

s = 'numbers: {:b}, {:o}, {:d}, {:x}, {:X}, {:.2%}'.format(10, 10, 10, 10, 10, 0.115)

print(s) # 'numbers: 1010, 12, 10, a, A, 11.50%'

19. 字符串首字母转大写 capitalize:

s = 'coco'.capitalize()

print(s) 'Coco'

20. 字符串全字符大写转小写(包含特殊字符,如俄美德字符БBß,希腊字符) casefold:

s = 'COCO'.casefold()

print(s) # 'coco'

21. 字符串全部转化为小写 lower:

s = 'COCO'.lower()

print(s) # 'coco'

22. 判断字符串是否是全是小写 islower:

s = 'Coco'.islower()

print(s) # False

23. 字符串全部转化为大写 upper:

s = 'coco'.upper()

print(s) # 'COCO'

24. 判断字符串是否全是大写 isupper:

s = 'COCO'.isupper()

print(s) # True

25. 大写字符串转小写，小写字符串转大写 swapcase:

s = 'cOcO'.swapcase()

print(s) # 'CoCo'

26. 字符串居中,可填充指定字符 rjust ljust center:

s = 'coco'.rjust(8, '*') # rjust 字符串居右填充指定子字符串

s1 = 'coco'.ljust(8, '?') # ljust 字符串居左填充指定子字符串

s2 = 'coco'.center(8, '-') # center 字符串居中填充指定子字符串

print(s, s1, s2) # '****coco' 'coco????' '--coco--'

27. 在字符串中查找子字符串出现的次数 count:

s = 'coco'.count('c')

s1 = 'coco'.count('c', 2, 3) # 参数要查找的字符串, 从第几个位置开始找, 找到那个位置结束

print(s, s1) # 2 1

28. 判断字符串是否以子字符串结尾/开头 endswith startswith:

s = 'coco'.endswith('o')

s1 = 'coco'.startswith('c')

print(s, s1) # True True

29. 把字符串中的制表符转为空格 expandtabs:

s = 'coco\t18'.expandtabs()

s1 = 'coco\t18'.expandtabs(6) # 指定以几个字符以断句，遇到制表符用空格补全几个字符

print(s) # 'coco 18'

print(s1) # 'coco 18'

30. 从开始向后查找子字符串，找到第一个后获取位置,找不到返回-1 find:

s = 'coco'.find('c') # 字符串的索引从0开始

s1 = 'coco'.find('c', 1, 3) # 可以指定开始和结束位置

print(s, s1) # 0 2

31. 从开始向后查找子字符串，找到第一个后获取位置,找不到程序报错 index:

s = 'coco'.index('c') # 字符串的索引从0开始

s1 = 'coco'.index('c', 1, 3) # 可以指定开始和结束位置

print(s, s1) # 0 2

32. 判断字符串是否只包含字母和数字 isalnum:

s = 'coco18'.isalnum()

print(s) # True

33. 判断字符串是否只包含字母汉字 isalpha:

s = 'coco欧豪'.isalpha()

print(s) # True

34. 判断字符串是否是数字 isdecimal isdigit isnumeric:

s = '123'.isdecimal() # 支持普通数字判断123，范围小

s1 = '1②3'.isdigit() # 还支持特殊数字判断②，范围中

s2 = '②二贰'.isnumeric() # 还支持中文数字判断二贰，范围大

print(s, s1, s2) # True True True

35. 判断变量名是否符合标识符 isidentifier:

s = 'coco_18'.isidentifier() # 即判断时候由字母数字下划线且不以数字开头组成的字符串

print(s) # True

36. 判断字符串中所有字符是否都是可打印字符(in repr())或字符串为空 isprintable:

s = 'coco\n\r\t18'.isprintable()

s1 = ''.isprintable()

s2 = 'coco18'.isprintable()

print(s, s1, s2) # False True True

37. 判断字符串是否全部是空格 isspace:

s = ' \r\n \t \r '.isspace()

print(s) # True

38. 把字符串转换成标题形式(每个被特殊字符隔开的字母首字母大写) title:

s = 'my name is coco'.title()

print(s) # 'My Mame Is Coco'

s1 = 'my,name*is唐coco'.title() # 中文也算特殊字符

print(s1) # 'My,Name*Is唐Coco'

39. 判断字符串是否是标题 istitle:

s = 'My Name Is Coco'.istitle()

print(s) # True

40. 去除字符串中的空白字符 lstrip rstrip strip:

s = '\r\n\t coco 18 '.lstrip() # lstrip祛除字符串左边的空白字符

s1 = '\r\n\t coco 18 '.rstrip() # lstrip祛除字符串右边的空白字符

s2 = '\r\n\t coco 18 '.strip() # lstrip祛除字符串两边的空白字符

print(s) # 'coco 18 '

print(s1) # ' coco 18'

print(s2) # 'coco 18'

41. 创建替换规则 maketrans,根据规则替换 translate:

s = 'coco 18'

s1 = str.maketrans('abc8', '1239')

print(s.translate(s1)) # '3o3o 19'

42. 字符串的替换 replace:

s = 'coco 18 男'.replace(' ', '--', 1) # 参数3表示只替换前几个

print(s) # 'coco--18 男'

43. 字符串分割 partition, rpartition, split, rsplit, splitlines:

s = 'abcd abcd abcd'

s1 = s.partition('a') # 指定分割符分成3份,含分隔符，前向后

s2 = s.rpartition('a') # 指定分割符分成3份,含分隔符，后向前

s3 = s.split('a', 3) # 按指定分隔符和次数分割，不含分隔符，前向后

s4 = s.rsplit('a', 3) # 按指定分隔符和次数分割，不含分隔符，后向前

s5 = 'abcd\n abcd\n abcd'.splitlines(True) # 根据换行符分割字符串, Ture:保留换行符,默认False:不保留换行符

print(s1) # ('', 'a', 'bcd abcd abcd')

print(s2) # ('abcd abcd ', 'a', 'bcd')

print(s3) # ['', 'bcd ', 'bcd ', 'bcd']

print(s4) # ['', 'bcd ', 'bcd ', 'bcd']

print(s5) # ['abcd\n', ' abcd\n', ' abcd']

44. 字符串的遍历:

s = 'my nane is coco'

for i in s:

print(i, end=' ') # m y n a n e i s c o c o

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

for item in enumerate('abcd'):

print('索引:%s 值:%s' % item)

结果:

索引:0 值:a

索引:1 值:b

索引:2 值:c

索引:3 值:d

for item in enumerate('abcd', 1):

print('序号:%s 值:%s' % item)

结果:

序号:1 值:a

序号:2 值:b

序号:3 值:c

序号:4 值:d

# 根据用户输入的字符串，遍历字符串

test1_str = input(">>>")

for item in range(0, len(test1_str)):

print(item, test1_str[item])

45. 计算字符串的长度 len:

s = 'coco'

print(len(s)) # 4

46. python2中字符串注意事项:

# 引号前面的u告诉解释器这是一个utf8编码格式的字符串

hello_str = u"hello世界"

print(hello_str) # hello世界

for c in hello_str:

print(c, end=' ') # h e l l o 世 界

04. 列表(list):

01. 列表的定义：

列表是由一系列元素组成的，元素与元素之间可能没有任何的关联关系，但他们之间有先后顺序关系

列表是一种容器

列表迭代对象

列表是可以被改变的序列, 属于可变的数据类型

02. 创建空列表的字面值:

L = [] # L 绑定空列表

L = list()

03. 创建非空列表的字面值:

L = [1, 2, 3, 4]

L = ['Beijing', 'shanghai', 'shenzhen']

L = [1, 'two', 3.3, '四']

L = [1, 2, [3.1, 3.2, 3.3], 4]

04. 列表的构造函数 list:

list() # 生成一个空的列表 等同于 []

list(iterable) # 用可迭代对象创建一个列表

示例：

>>> list()

[]

>>> list("hello") # 字符串转列表，每一个子字符串就是一个列表元素

['h', 'e', 'l', 'l', 'o']

>>> list(range(1, 10, 2))

[1, 3, 5, 7, 9]

05. 列表的运算:

运算符:

+ += * *=

示例:

+ 用于拼接列表:

x = [1,2,3]

y = [4,5,6,7]

z = x + y # z = [1, 2, 3, 4, 5, 6, 7]

+= 用原列表与右侧列表拼接，并用变量绑定新列表:

x = [1,2,3]

x += [4,5,6] # x = [1,2,3,4,5,6]

* 生成重复的列表

x = [1,2] * 3 # x = [1,2,1,2,1,2]

y = 3 * [5,6] # y = [5,6,5,6,5,6]

*= 生成重复的列表，并给原变量赋值:

x = [3,4]

x *= 2 # x = [3,4,3,4]

y = 3

y *= [7,8] # y = [7,8,7,8,7,8]

06. 列表的比较运算:

运算符:

< <= > >= == !=

示例：

[1,2,3] < [1,2,4] # True

[1,3] > [1,2,4] # True

[5] < [5, 0] # True

["ABC", "123"] > ['abc', '456'] # False

[1, "two"] > ["two", 1] # TypeError

[1, 2] < [3.3, 4] # True

[1] < ['2'] # TypeError

07. 列表的 in / not in 运算符:

in 判断一个对象是否存在于容器内，如果存在返回True,否则返回False,用法同字符串的 in 相同

语法:

数据对象 in 容器

示例：

L = [1, 'Two', 3.3, '四']

1 in L # True

2 in L # False

3.3 in L # True

'4' not in L # True

08. 列表的索引取值：

语法:

列表[整数表达式]

用法:

取值时，等同于字符串的索引操作

索引分为正向索引和反向索引，规则与字符串索引规则完全相同

列表的索引赋值

列表是可变的序列，可以通过索引赋值改变列表中的元素

示例:

L = [1,2,3,4]

L[2] = 3.3 # 将第三个元素改为 3.3

列表的降维操作示例:

li_list = [1, 2, 3, [11, ["zhangsan", 100], 12, 13], 5, 6]

v1 = li_list[3][1][0][0:5] # 取子列表值

print(v1)

09. 列表的切片:

语法:

列表[:]

列表[::]

列表的切片取值时，返回一个列表，规则等同于字符串切片规则

列表的切片赋值:

可以改变原列表的排序，可以插入和修改数据

可以用切片改变列表的对应元素的值

语法:

列表[切片] = 可迭代对象

注: 赋值运算符的右侧必须是一个可迭代对象

示例:

L = [2, 3, 4]

L[0:1] = [1.1, 2.2] # L = [1.1,2.2,3,4]

L = [2, 3, 4]

L[1:] = [3.3, 4.4, 5.5]#L=[2,3.3,4.4,5.5]

L = [2, 3, 4]

L[:] = [0, 1] # L = [0, 1]

L = [2, 4] # 实现中间插入 [3.1, 3.2]

L[1:1] = [3.1, 3.2] # L = [2,3.1,3.2,4]

L = [2,3,4] # 实现在前面插入[0,1]

L[0:0] = [0, 1]

L = [2,3,4] # 实现在后面插入[5,6]

L[-1:-1] = [5, 6]

L = [1,4] # 用range函数生成的可迭代对象赋值

L[1:1] = range(2,4)

L = [2,3,4]

L[1:2] = "ABCD" # "ABCD"也是可迭代对象

切片赋值注意事项:

对于步长不等于1的切片赋值，赋值运算符右侧的可迭代对象提供的元素个数一定要等于切片切出的段数

示例:

L = [1,2,3,4,5,6]

L[::2] = "ABC" # 对的

# 以下切出三段，但给出5个元素填充是错的

L[::2] = "ABCDE"

10. del 语句用于删除列表中的元素:

语法:

del 序列[整数表达式]

del 序列[切片]

示例:

L = [1,2,3,4,5,6]

del L[-1] # 删除最后一个 6

del L[0] # 删除第1个 1

del L[::2] # 删除 2,4

11. 列表与字符串比较:

1. 列表和字符串都是序列，元素之间有先后关系

2. 字符串是不可变的序列，而列表是可变的序列

3. 字符串中每个元素只能存储字符，而列表可以存储任意类型的元素

4. 列表和字符串都是可迭代对象

12. 列表推导式 list comprehension:

列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

作用：

用简易方法生成列表

语法:

[表达式 for 变量 in 可迭代对象]

[表达式 for 变量 in 可迭代对象 if 真值表达式]

示例1：

常规写法

[1, 4, 9, 16, 25, .... 81]

L = []

for x in range(1, 10):

L.append(x ** 2)

用列表推导式生成:

L = [x**2 for x in range(1, 10)]

示例2：

生成[1, 9, 25, 49, 81] 列表，跳过所有的偶数

L = [x ** 2 for x in range(1, 10) if x % 2 == 1]

示例3:

# 30以内所有能被3整除的数的平方

def squared(x):

return x*x

multiples = [squared(i) for i in range(30) if i % 3 is 0]

print(multiples)

13. 列表推导式的嵌套:

语法:

[表达式1

for 变量1 in 可迭代对象1 if 真值表达式1

for 变量2 in 可迭代对象2 if 真值表达式2

]

示例:

生成['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

L = [x+y

for i in range('ABC')

for j in range('123')

]

14. 根据值取索引 index:

L = ['coco', 18, '男']

L.index(18) # 1

15. 增加 append, insert, extend:

L = ['coco']

L.append('男') # append 方法可以向列表的末尾追加数据

L.insert(1, 18) # insert 方法可以在列表的指定索引位置插入数据

L.extend(['cat', 3]) # extend 方法可以把其他列表中的完整类容追加到当前列表的末尾

L.extend('foo') # 遍历添加，参数：可迭代对象

print(L) # ['coco', 18, '男', 'cat', 3, 'f', 'o', 'o']

16. 删除 remove, pop, clear:

L = ['coco', 18, '男', 'cat', 3]

# remove 方法可以从列表中删除指定的数据, 仅删除第一次出现的数据, 如果数据不存在，程序会报错

L.remove('coco') # L = [18, '男', 'cat', 3]

# pop方法可以指定要删除元素的索引, 默认删除最后一个元素, 并返回被删除的元素, 如果索引不存在，程序会报错

s = L.pop(0) # L = ['男', 'cat', 3] s = 18

L.clear() # 清空列表 L = []

17. 统计列表中元素的总数(取列表的长度) len:

L = ['coco', 18, '男']

print(len(L)) # 3

18. 统计列表中某一个数据出现的次数 count:

L = ['coco', 18, '男', 'coco']

print(L.count('coco')) # 2

19. 列表的排序 sort, reverse:

num_lst = [6, 8, 4, 1, 10]

num_lst.sort() # sort默认升序 参数reverse默认值是False

print(num_lst) # [1, 4, 6, 8, 10]

num_lst.sort(reverse=True) # 降序

print(num_lst) # [10, 8, 6, 4, 1]

num_lst.reverse() # 逆序(翻转)

print(num_lst) # [1, 4, 6, 8, 10]

20. 列表的遍历:

num_lst = [6, 8, 4, 1, 10, 'abc', 'd']

for item in num_lst:

print(item, end=' ') # 6 8 4 1 10 abc d

# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

for item in enumerate(num_lst):

print('索引:%s 值:%s' % item)

结果:

索引:0 值:6

索引:1 值:8

索引:2 值:4

索引:3 值:1

索引:4 值:1

索引:5 值:abc

索引:6 值:d

for item in enumerate(num_lst, 1): # 设置遍历开始初始位置，只改变了起始序号

print('序号:%s 值:%s' % item)

结果:

序号:1 值:6

序号:2 值:8

序号:3 值:4

序号:4 值:1

序号:5 值:10

序号:6 值:abc

序号:7 值:d

21. 列表在循环的时候不能删:

list在循环的时候不能删. 因为会改变索引

示例1:

lst = ["我不是药神", "西游记", "西红柿首富", "天龙八部"]

del_lst = []

for el in lst:

del_lst.append(el) # 记录下来要删除的内容

for el in del_lst: # 循环记录的内容

lst.remove(el) # 删除原来的内容

print(lst)

示例2:

lst = ["周杰伦", "周润发", "周星星", "马化腾", "周树人"]

# 删除掉姓周的人的信息

del_lst = []

for el in lst:

if el.startswith("周"):

del_lst.append(el)

for el in del_lst:

lst.remove(el)

print(lst)

22. 列表解析:

就是列表推导式与三元表达式的运用

三元表达式: ret = 成立执行 if 真值表达式 else 不成立执行

示例:

egg_list1 = []

for i in range(10):

egg_list1.append("数字%s" % i)

print(egg_list1)

egg_list2 = ["数字%s" % i for i in range(10)]

egg_list3 = ["数字%s" % i for i in range(10) if i%2 != 0]

print(egg_list2)

print(egg_list3)

05. 元祖(tuple):

01. 元组的定义:

元组是由一系列元素组成的，元素与元素之间可能没有任何的关联关系，但他们之间有先后顺序关系

元组是一种容器

元组是可迭代对象, 是不可变的列表, 一级元素不能修改删除添加

元组是不可以被改变的序列, 属于不可变的数据类型, 但是元组中的元素可是任意类型的

02. 表示方法:

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

元组创建在最后一位加，方便和函数参数区分

03. 创建空元组的字面值:

t = ()

t = tuple()

04. 创建非空元组的字面值:

t = 200,

t = (20,)

t = (1,2,3)

t = 100, 200, 300

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

05. 元组的错误示例:

t = (20)

x, y, z = 100, 200, 300 # 序列赋值

x, y, z = (100, 200, 300) # 序列赋值

x, y, z = [100, 200, 300] # 序列赋值

x, y, z = "ABC" # 序列赋值

06. 元组的构造(创建)函数 tuple:

tuple() 生成一个空元组，等于同()

tuple(iterable) 用可迭代对象生成一个元组

07. 元组的运算:

元组的所有运算同列表的运算方式一致

算术运算:

+ += * *=

比较运算

< <= > >= == !=

in / not in 运算

08. 索引和切片:

元组的索引和切片等同于列表的索引和切片

元组的切片返回一个元组

元组不能索引赋值和切片赋值

09. 元组的方法:

T.count(value) 返回元素个数（同list.count)

T.index(value, [start, [stop]]) 返回某个元素在元组的索引位置（同list.index)

06. 字典(dict):

01. 字典的定义:

字典是一种可变的容器,可以存储任意类型的数据

字典中的每个数据都是用'键'进行索引的，而不像序列可以用下标(index)来进行索引

字典中的数据没有先后顺序关系, 字典的存储是无序的

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

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

字典(dict)是一个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯一的,

在保存的时候, 根据key来计算出一个内存地址, 然后将key-value保存在这个地址中.

这种算法被称为hash算法, 在dict中存储的key-value中的key必须是可hash的

已知的可哈希(不可变)的数据类型: int, str, tuple, bool

不可哈希(可变)的数据类型: list, dict, set

02. 字典的字面值的表示方式:

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

03. 创建空字典:

d = {} # d绑定空字典

d = dict()

04. 创建非空字典:

d = {'name': 'tarena', 'age': 16}

d = {'year': 2018, 'month': 4, 'day':1}

05. 字典的构造函数 dict:

dict() 生成一个空字典，等同于 {}

dict(iterable) 用可迭代对象初始化一个字典

dict(**kwargs) 用命名关键字传参形式生成一个字典

示例:

d = dict()

d = dict([('name', 'tarena'), ('age', 15)])

d = dict(name='tarena', age=15)

06. 字典的键为不可变类型:

不可变类型:

bool, int, float, complex, str, tuple, frozenset(固定集合), bytes(字节串)

包括: None

07. 可变的类型(不能充当字典的键):

list, dict, set(集合), bytearray(字节数组)

08. 字典的基本操作:

键索引:

字典[键]

示例:

>>> d = {'name': 'tarena', 'age': 15}

>>> d['name']

'tarena'

>>> d['age']

15

添加/修改字典元素:

字典[键] = 值对象

示例：

d = {}

d['birthday'] = (2002, 1, 1) # 添加键值对

d['age'] = 16 # 添加键值对

d['age'] = 17 # 修改'age'键所对应的值

删除字典元素 del 语句:

del 字典[键]

示例:

d = {'name': 'tarena', 'age': 16}

del d['age'] # 删除'age'这个键

09. 列表的 in 运算符和字典的 in 运算符比较:

01. 列表的in运算符计算时间会因列表中元素个数的增加而增加

L = [3,7,0,1,4,5,6....... 10976] # 大约有十万个

if 888 in L:

print("888在列表里") # 慢

02. 字典的in运算符计算时间不会因键值对的个数增加而增加,操作速度快于列表

d = {3: "三", 7: "xx", 0: None, ... 10976:None}

if 888 in d:

print("888在字典的键里") # 快

10. 字典的迭代访问：

循环获取key值:

d = {'name': '小张', 'birthday': (2008,8,8)}

for k in d.keys(): # .keys是默认调用的方法可不写，循环key值

print(k, end=' ') # name birthday

循环value值:

d = {'name': '小张', 'birthday': (2008,8,8)}

for k in d.values():

print(k, end=' ') # 小张 (2008, 8, 8)

循环获取键值对:

d = {'name': '小张', 'birthday': (2008,8,8)}

for k in d.items():

print(k, end=' ') # ('name', '小张') ('birthday', (2008, 8, 8))

11. 可以用于字典的内建(built-in)函数:

len(x) 返回字典的键值对的个数

max(x) 返回字典的键的最大值

min(x) 返回字典的键的最小值

sum(x) 返回字典的所有键的和

any(x) 对所有键进行真值测试，有一个为True结果为True

all(x) 对所有键进行真值测试，所有为True才为True

12. 字典推导式:

作用：

用可迭代对象生成字典

语法:

{键表达式 : 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}

注: []的内容代表可省略

示例1:

# 生成一个字典，键为10以内的数字,值为键的平方

d = {x : x ** 2 for x in range(10)}

示例2:

# 将一个字典的key和value对调

mcase = {'a': 10, 'b': 34}

mcase_frequency = {mcase[k]: k for k in mcase}

print(mcase_frequency)

示例3:

合并大小写对应的value值，将k统一成小写

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}

print(mcase_frequency) # {'a': 17, 'b': 34, 'z': 3}

13. 字典 fromkeys() 函数用于创建一个新字典:

以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值

示例:

dic = dict.fromkeys(["k1", 2, ("k3", 3)], 999)

print(dic) # {'k1': 999, 2: 999, ('k3', 3): 999}

v1 = dic.get("k11", 111) # 取key不存在是返回指定参数111，避免报错

print(v1) # 111

示例2:

a = dict.fromkeys(["jj", 'jay', 'yy'], "sb") # 静态方法

print(a) # {'jj': 'sb', 'jay': 'sb', 'yy': 'sb'}

dic = {"a":"123"}

s = dic.fromkeys("coco", "cat" ) # 返回给你一个新字典

print(s) # {'c': 'cat', 'o': 'cat'}

14. 字典的常用方法函数 pop, popitem, setdefault:

pop 指定参数在key正确时返回value, key错误时，返回指定参数

popitem 随机删除一个键值对,返回一个键值对元组

setdefault kye存在获取对应的value值，不存在添加键值返回添加的value值

示例:

dic = {'k1': 'v1', 'k2': 'v2'}

v = dic.pop("k1", 90) # v='v1' dic={'k2': 'v2'}

v2 = dic.pop("k22", 90) # v2=90

v3, v4 = dic.popitem() # v3='k2', v4='v2'

v5 = dic.setdefault("k1","123") # v5='123' dic={'k1': '123'}

15. 字典的合并 update, 清除 clear, 统计键值对数量 len():

如果被合并的字典包含已经存在的键值对，会覆盖原有的键值对

例如:

card_dict = {"name": "coco", "age": 16}

infor_dict = {"height": 1.6, "age": 15} # age值覆盖

card_dict.update(infor_dict) # {'name': 'coco', 'age': 15, 'height': 1.6}

# 参数自动转换为字典更新到字典

card_dict.update(k1=1, k2="123") # {'name': 'coco', 'age': 15, 'height': 1.6, 'k1': 1, 'k2': '123'}

print(len(card_dict)) # 5

print(card_dict.clear()) # {}

16. 字典不能在循环的时候更改大小:

dic = {"a":"123", "b":"456"}

for k in dic:

dic.setdefault("c", "123") # 报错

07. 集合(set):

1.定义:

集合是可变的容器

集合内的数据对象都是唯一的（不能重复多次的)

集合是无序的存储结构，集合中的数据没有先后顺序关系

集合内的元素必须是不可变对象

集合是可迭代对象

集合是相当于只有键没有值的字典(键则是集合的数据)

set集合中的元素必须是可hash的, 但是set本⾝身是不可hash的

2.创建空的集合:

set()

3.创建非空的集合:

s = {1, 2, 3, 4}

4.集合的构造函数 set

set() 创建一个空的集合对象(不能用{}来创建空集合)

set(iterable) 用可迭代对象创建一个新的集合对象

示例:

s = set() # s 为空集合

s = {3,5,7,9}

s = set("ABC") # s = {'A', 'B', 'C'}

s = set({1:'1', 2:"2", 5:'5'}) # s = {1,2,5}

s = set(range(1:10:3))

print(s) # s = {1,4,7}

s2 = set("index ix") # 字符串转换集合

print(s2) # s2 = {'n', 'i', 'e', 'x', 'd', ' '}

s3 = set(["index", "index", 11]) # 列表转集合

print(s3) # {'index', 11}

05. 集合的常用方法 add, copy, pop, remove, discard, update, clear:

add 添加元素:

s4 = {1, 2, 3, 4}

s4.add("1")

print(s4) # {1, 2, 3, 4, '1'}

clear 清空集合:

s5 = {"aa" ,(1, 2), 1}

s5.clear()

print(s5) # set()

copy 集合的浅拷贝:

s6 = {1, 2, 3, 4}

s7 = s6.copy()

print(s7) # {1, 2, 3, 4}

pop 随机删除集合元素 remove discard 指定删除元素:

s7 = {1, 2, 3, 4}

s7.pop() # 随机删除一个元素

s7.remove(2) # 删除指定元素，指定不存在会报错

s7.discard(3) # 删除指定元素，指定不存在不会报错

print(s7) # {4}

update 更新集合:

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s1.update(s2) # 把s2合并到s1并更新s1集合，更新多个值

print(s1) # {1, 2, 3, 4, 5}

s1.add(6) # add更新一个元素

print(s1) # {1, 2, 3, 4, 5, 6}

5.集合的运算:

交集， 并集， 补集(差集)， 交叉补集(对称补集), 子集， 超集 交集判断

& | - ^ < >

intersection union difference symmetric_difference issubset issuperset isdisjoint

运算符:

& | - ^ < <= > >= == !=

in / not in

& 生成两个集合的交集:

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s1 & s2 # {2, 3}

s1.intersection(s2) # {2, 3}

判断两个集合有咩有交集, 没有交集返回True，有返回False

s1.isdisjoint(s2) # False

| 生成两个集合的并集:

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s1 | s2 # {1, 2, 3, 4}

s1.union(s2) # {1, 2, 3, 4}

- 生成两个集合的补集(差集):

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s1 - s2 # {1} #生成属性s1但不属于s2的所有元素的集合

s1.difference(s2) # {1}

^ 生成两个集合的对称补集(交叉补集):

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s1 ^ s2 # {1, 4}

s1.symmetric_difference(s2) # {1, 4}

> 判断一个集合是另一个集合的超集

< 判断一个集合是别一个集合的子集:

{1, 2, 3} > {1, 2} # True

{2, 3, 1} > {3, 2} # True

{2, 3, 1}.issuperset({3, 2}) # True

{2, 3, 4} < {1, 2, 3, 4} # True

{2, 3, 4}.issubset({1, 2, 3, 4}) # True

== / != 集合相同和不同

{1, 2, 3} == {3, 2, 1} # True

{1, 2, 3} != {2, 3, 4} # True

in / not in 运算符:

in 等同于字典的in， 用于集合中，当某个值存在于集合中，返回True,否则返回False

not in 与 in 返回值相反

集合的 in / not in 运算符的速度快于序列

6.集合推导式:

集合推导式是用可迭代对象生成集合的表达式

语法:

{ 表达式 for 变量 in 可迭代对象 [if 真值表达式]}

注: [] 内的内容可省略

示例:

numbers = (1,2,3,2,2,3,3,4,5)

s = {x for x in numbers} # 去除重复的元素

7.固定集合 frozenset:

定义:

固定集合是不可变的，无序的，含有不重复元素的集合, 不能增加删除修改

作用：

固定集合可以作为字典的键，还可以作为集合的值

创建空的固定集合:

fs = frozenset()

创建非空的固定集合:

frozenset(iterable) 用可迭代对象创建新的固定集合

示例:

fz = frozenset([2,3,5,7]) # frozenset({2, 3, 5, 7})

08. 字节串(bytes):

释义:

也叫做字节序列

存储以字节为单位的数据

字节串是不可改变的序列

字节是 0~255之间的整数

01. 创建空的字节串的字面值:

b''

b""

b''''''

b""""""

02. 创建非空的字节串的字面值:

B = b'hello'

B = b"Hello"

B = b'''abcd'''

B = b"""abcd"""

B = b'abc\n123'

B = b'\x41\x42'

b'\x16\x0d\x0d\x0a'

03. 字节串的构造函数 bytes:

bytes() 生成一个空的字节串 等同于b''

bytes(整数可迭代对象) 用可迭代对象初始化一个字节串

bytes(整数n) 生成n个值为0的字节串

bytes(字符串, encoding='utf-8') 用字符串的转换编码生成一个字节串

04. bytes 的运算:

+ += * *=

< <= > >= == !=

in / not in

索引和切片

in / not in 示例:

B = b'ABCDE'

0x41 in B # True

05. 用于序列的函数:

len, max, min, sum, any, all 都可用于字节串

06. bytes与 str的区别:

bytes 存储字节(0~255)

str 存储字符(Unicode值)

bytes 与 str转换

编码(encode)

str ----> bytes

b = s.encode(encoding='utf-8')

解码(decode)

bytes ----> str

s = b.decode(encoding='utf-8')

例:

b = "你好".encode('utf-8')

print(b)

s = b.decode('utf-8')

print(s)

09. 字节数组 bytearray:

释义:

可变的字节序列

01. 创建函数 bytearray:

bytearray() 创建空的字节串

bytearray(整数)

bytearray(整型可迭代对象)

bytearray(字符串, encode='utf-8')

02. 字节数组 bytearray 的操作:

+ += * *=

< <= > >= == !=

in / not in

索引 index / 切片 slice

(字节数组可以索引和切片赋值，赋值规则同列表的索引和切片赋值相同)

例:

ba = bytearray(b'abcdefg')

ba[0] = 0x41 # ba = bytearray(b'Abcdefg')

ba[1::2] = bytearray(b'BDF') # 修改bdf为大写

03. 字节数组 bytearray 的方法:

BA代表bytearray

BA.clear() 清空字节数组

BA.append(n) 追加一个字节(n为0~255的整数)

BA.remove(value) 删除第1个出现的字节,如果没有出现，则触发ValueError错误

BA.reverse() 字节的顺序反转

BA.decode(encoding='utf-8') 将bytearray转换为字符串

BA.find(sub[, start[, end]]) 查找sub 子节数数组

Python的特殊数据类型:

01. 空值 None

None 是一个表示不存在的特殊对象

作用：

01. 用来语法占位

02. 变量解除绑定