Python数据类型汇编

1.基本概念

1.1表达式

（1）表达式（类似数学公式），是由数字、运算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合
（2）表达式特点
①表达式⼀般仅仅用于计算⼀些结果，不会对程序产⽣实质性的影响
②如果在交互模式中输⼊⼀个表达式，解释器会自动将表达式的结果输出

1.2语句

（1）⼀个语法上自成体系的单位，它由⼀个词或句法上有关连的⼀组词构成
（2）语句的执行⼀般会对程序产生⼀定的影响,在交互模式中不⼀定会输出语句的执行结果
（3）代码块：执行的话，都会执行，不执行的话，一个也不会执行

1.3程序（program）

程序就是由⼀条⼀条的表达式和⼀条⼀条的语句构成的

1.4函数（function）

（1）函数就是⼀种语句，函数专门用来完成特定的功能
（2）函数形如：xxx()
（3）函数的分类：
①内置函数 : 或者内建函数，就是由语法规定存在的函数，这些函数，包含在编译器的运行库中，程序员不必单独书写代码实现它，只需要调用即可。
②自定义函数 : 由程序员自主创建的函数 。
（4）函数的2个要素
①参数（）
②返回值

2.标识符

2.1 关键字（保留字）

python⼀些具有特殊功能的标识符，这就是所谓的关键字，是python已经使用了的，所以不允许开发者自己定义和关键字相同名字的标识符

• 33个保留字

2.2 标识符

（1）开发人员在程序中自定义的⼀些符号和名称。标识符是自己定义的,如变量名、函数名等

（2）组成:由26个英文字母大小写，数字 0-9 ，符号 _ $

（3）标识符的规则:
①标识符中可以包含字母、数字、—，但不能使用数字开头
②不能使用关键字和保留字作为标识符

（4）命名方式
①驼峰命名法
小驼峰式命名法： 第⼀个单词以小写字母开始；第⼆个单词的首字母大写，例如：myName、aDog
大驼峰式命名法： 每⼀个单字的首字母都采用写字母，例如：FirstName、LastName
②下划线命名法
就是用下划线“—”来连接所有的单词，如get-url buuffer-size

3. 基本数据类型

数据类型指的就是变量的值的类型，也就是可以为变量赋哪些值

3.1 数字类型（整数/小数/复数）

• 整数（int） :
  所有整数 例如 : a = 1 b = 100 c =999_233_345(科学计数法）
  存在溢出

• 浮点数（float） :
  所有⼩数 例如 a = 1.2 b=6.66

  0.2/0.1先转换为二进制，算完再转为十进制，所以存在如下误差（不确定尾数）
  

#数字比较
print(0.1+0.2==0.3)
#False
#使用round函数去掉不确定尾数（round(x,d)函数：四舍五入，奇进偶不进）
print(round(0.1+0.2,1)==0.3)
#True

• 复数（complex(实部，虚部））
  ①复数类型表示数学中的复数。复数中有一个基本单位元素j，它被定义为j=\sqrt{-1},叫“虚数单位”。含有虚数单位的数被称为复数。
  ②python语言中，复数可以看作是二元有序实数对（a,b)，表示a+bj,a为实部，b为虚部，虚部用后缀“J”或者“j”来表示。（注意：b为1时，1不能省略，即1j表示复数，而j则表示python程序中的一个变量。
  ③复数中的实部和虚部都是浮点类型，对于复数z可以用z.real和z.imag分别获得它的实数部分和虚数部分。

print((1.23e2+1.57j).real,(1.23e2+1.57j).imag,1.23e2+1.57j.imag)
#123.0 1.57 124.57

3.2 布尔值（bool）和空值

• 布尔值（特殊整型int）: 只有2个值⼀个是True（1） ⼀个是False（0）
• 用作布尔表达式（如用作 if 语句中的条件）时，下面的值都将被解释器视为假（共10种）： 0 0.0 0j False " " () [] {} set() None
  其中None是python关键字，代表空，一般用于初始话操作
• 布尔值 True 和 False 属于类型 bool ，而 bool 与 list 、 str 和 tuple 一样，可用来转换其他的值。

print(1+True)
print(1+False)

3.3 自动类型转换

精度从低到高 bool < int < float < compex
自动类型转换，默认从低精度向高精度进行转化（从低到高）

• bool+int =int
• bool+float=float

4 变量

4.1变量的概念？

（1）变量是计算机内存中的⼀块区域，存储规定范围内的值，值可以改变，通俗的说变量就是给数据起个名字。
（2）变量命名规则：
①变量名由字母、数字、下划线组成，要符合标识符的命名规范
②数字不能开头
③不能使用关键字
注意 : 是两个对象相等和两个对象是同⼀个对象是两个概念

不同于其他一些语言， 使用Python变量前必须给它赋值，因为Python变量没有默认值。

4.2变量的运算

变量的运算就是正常的四则运算 ,需要注意的是在运算过程中含有浮点数，那么它返回的就是⼀个浮点数类型(除法运算时结果都是浮点型)

5 字符串（不可变序列）

5.1 什么是字符串

字符串是由数字、字母、下划线组成的⼀串字符，也是一种序列
①Python中用 ⼀对双引号或者⼀对单引号包裹的内容就是字符串
②单引号或者双引号不能混合使⽤

注：Python没有专门用于表示字符的类型，因此一个字符就是只包含一个元素的字符串。

5.11类str

print(str("Hello,\nworld!"))
#Hello,
#world!

5.12函数repr

print(repr("Hello,\nworld!"))
#'Hello,\nworld!'

5.2 转义字符

转义字符是⼀种特殊的字符常量。转义字符以反斜线"\"开头,后跟⼀个或几个字符。转义字符具有特定的含义,不同于字符原有的意义,故称“转义”字符
① \t 表示制表符
② \n 表示换行符（New line）
③ \ 表示反斜杠

#输出c:\news
#法一
dos='c:\\news'
print(dos)
#法二
dos=r'c:\news'
print(dos)

④ \表示后面跟着的这个字符就是本身字符的意思，不做其他使用
\ ’ 表示 ’
\ ‘’ 表示 ‘’
⑤\r是回车符（Carriage return）

5.3 长字符串

（1）长字符串又叫做文档字符串，我们使用三重引号来表示⼀个长字符串’’’ ‘’’/’’’’’’ ‘’’’’’
（2）三重引号可以换行，并且会保留字符串中的格式

print('''This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.''')

注：
常规字符串也可横跨多行。只要在行尾加上反斜杠，反斜杠和换行符将被转义，即被忽略。
例如，如果编写如下代码（各型式效果相同）：

#法一
print("Hello, world!")
#法二
print("Hello, \ world!")
#法三
print ('Hello,\
 world')

5.4原始字符串

原始字符串（r+字符串）不以特殊方式处理反斜杠，因此在有些情况下很有用。

print(r'C:\nowhere')
#C:\nowhere
print(r'C:\Program Files\fnord\foo\bar\baz\frozz\bozz')
#C:\Program Files\fnord\foo\bar\baz\frozz\bozz

5.5 格式化字符串

5.5.1格式化字符串 （拼串）

s='good'
print('s='+s)

5.5.2格式化字符串（参数传递）

s='good'
print('s=',s)

5.5.3格式化字符串（占位符）

%s 字符串占位
%f 浮点数占位(%.3f 将值的格式设置为包含3位小数的浮点数)
%d 整数占位

name = "Monty Python"
print("Hello, %s." % name)
#'Hello, Monty Python.'

name = "Monty Python"
age = 100
#利用元组(name, age)将待插入的多个变量包在一起
print("Hello, %s. You are %d years old" % (name, age))
#'Hello, Monty Python. You are 100 years old'

5.5.4格式化字符串 （str.format()）

5.5.4.1format()方法的基本使用

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

• <模板字符串>：一个由字符串和槽组成的字符串，用来控制字符串和变量的显示效果

name = "Eric"
age = 100
#使用str.format()，字符串中待替换的域使用{}表示
print("Hello, {}. You are {}.".format(name, age))
# 'Hello, Eric. You are 100.'

name = "Eric"
age = 100
#通过索引的方式指定format()中哪一个变量和值应该填入哪一个{}
print("Hello, {1}. You are {0}.".format(age, name))
# 'Hello, Eric. You are 100.'

name = "Eric"
age = 100
#通过指定名称的方式表明format()中哪一个变量和值应该填入哪一个{}
print("Hello, {name}. You are {age}.".format(age=age, name=name))
#'Hello, Eric. You are 100.'

待格式化的信息都来自一个字典时：

person = {'name': 'Eric', 'age': 100}
"Hello, {name}. You are print({age}.".format(name=person['name'],age=person['age']))
#'Hello, Eric. You are 100.'

person = {'name': 'Eric', 'age': 100}
#上面的程序还能利用字典拆包**进一步简化
print("Hello, {name}. You are {age}.".format(**person))
#'Hello, Eric. You are 100.'

#在模板字符串中直接输出大括号
print('{1}曰：{{学而时习之，不亦{0}}}。'.format('说乎','孔子'))
#孔子曰：{学而时习之，不亦说乎}。

5.5.4.2format()方法的格式控制

format()方法的槽除了包括参数序号，还可以包括格式控制信息，语法格式如下：

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

• 格式控制标记用来控制参数显示时的格式，格式内容如下:

:	<填充>	<对齐>	<宽度>	<,>	<精度>	<类型>
引导符号	用于填充的单个字符	<左对齐 >右对齐 ^居中对齐	槽的设定输出宽度	数字的千位分割符	①浮点数小数部分的精度②字符串的最大输出长度	①整数类型b,c,d,o,x,X②浮点数类型e,E,f,%

5.5.4.2.1显示格式规范

• <填充>:可以修改默认填充字符，填充字符只能有一个
• < 对齐>:指定左对齐、右对齐和居中，可分别使用 < 、 > 和 ^
• < 宽度>:指当前槽的设定输出字符宽度，如果该槽参数实际值比宽度设定值大，则使用参数实际长度；如果该值的实际位数小于指定宽度，则按照对齐指定方式在宽度内对齐，默认以空格字符补充

s='Self-discipline is freedom'
#宽度
print('trust yourself,{:30}'.format(s))
#对齐
print('trust yourself,{:^30}'.format(s))
#填充
print('trust yourself,{:*^30}'.format(s))
'''
trust yourself,Self-discipline is freedom
trust yourself,  Self-discipline is freedom
trust yourself,**Self-discipline is freedom**
'''

格式控制标记可以用变量来表示，即用槽来指定所对应的控制标记及数量

#注意用变量来表示格式控制标记时，：前需加0
print('trust yourself,{0:{1}{2}{3}}'.format(s,'*','^',30))
#trust yourself,**Self-discipline is freedom**

5.5.4.2.2数值本身规范

• <,>：数字类型的千位分隔符。
• <.精度>：由小数点（.）开头。对于浮点数，精度表示小数点输出的有效位数。对于字符串，精度表示输出的最大长度。此时小数点可以理解为对数值的有效截断；如果小数点保留长度超过应输出长度，以应输出长度为准。
• <类型>：表示输出整数和浮点数类型的格式规则。
  （1）整数类型，输出格式包括如下6种
  ①b:输出整数的二进制方式；
  ②c:输出整数对应的Unicode字符；
  ③d:输出整数的十进制方式；
  ④o:输出整数的八进制方式；
  ⑤x:输出整数的小写十六进制方式；
  ⑥X:输出整数的大写十六进制方式。
  （2）浮点数类型，输出格式包括如下4种
  ①e:输出浮点数对应的小写字母e的指数形式；
  ②E:输出浮点数对应的大写字母E的指数形式；
  ③f:输出浮点数的标准浮点形式；
  ④%:输出浮点数的百分比形式。

s=12345.67890
print('trust yourself,{:*^30,}'.format(s))
print('trust yourself,{:*^30,.2f}'.format(s))
'''
trust yourself,*********12,345.6789**********
trust yourself,**********12,345.68***********
'''

5.5.5格式化字符串（f-string）~~~f+’{变量}’

适用范围：有变量指向

name = "Eric"
age = 100
print(f"Hello, {name}. You are {age}.")
# 'Hello, Eric. You are 100.'

5.6字符串操作符

操作符	描述
x+y	连接两个字符串x与y
x*n或n*x	复制n次字符串x
x in s	如果x是s的子串，返回True，否则返回False

s='trust yourself'+'Self-discipline is freedom'
print(s[0:14]*2)
print('trust' in s)
'''
输出如下结果：
trust yourselftrust yourself
True
'''

5.7字符串处理函数

python提供了如下对字符串处理的内置函数：

函数	描述
len(x)	返回字符串x的长度 ,也返回其它组合数据类型的元素个数
chr(x)	返回Unicode编码x对应的单字符
ord(x)	返回单字符x表示的Unicode编码
bin(x)	返回整数x对应的二进制数的小写形式字符串
oct(x)	返回整数x对应的八进制数的小写形式字符串
hex(x)	返回整数x对应的十六进制数的小写形式字符串

print(chr(0x025b),chr(0x2708),chr(0x00A5),chr(0x266B))
#ɛ ✈ ¥ ♫

5.8字符串处理方法

• “方法”是程序设计中的一个专有名词，属于面向对象程序设计领域。在python解释器内部，所有数据类型都采用面向对象方式实现，因此大部分数据类型都有一些处理方法。
• 方法也是一个函数，只是调用方式不同。函数采用func(x)方式调用，而方法则采用<a>.func(x)形式调用即A.B（）形式。

（1）center（字符串居中）

方法 center 通过在两边添加填充字符（默认为空格）字符串居中。

#str.center(width,fillchar)
print("The Middle by Jimmy Eat World".center(39))
#' The Middle by Jimmy Eat World '

print("The Middle by Jimmy Eat World".center(39, "*"))
#'*****The Middle by Jimmy Eat World*****'

附： ljust 、 rjust 和 zfill 。

（2）find（子串索引）

方法 find 在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回 -1 。

print('With a moo-moo here, and a moo-moo there'.find('moo'))
#7

title = "Monty Python's Flying Circus"
print(title.find('Python'))
#6
print(title.find('Zirquss'))
#-1

#指定索引的起点终点（左闭右开区间）
subject = '$$$ Get rich now!!! $$$'
print（subject.find('$$$')）
#0
print(subject.find('$$$', 1)) # 只指定了起点
#20
print(subject.find('!!!'))
#16
print(subject.find('!!!', 0, 16) )# 同时指定了起点和终点
#-1

附：rfind 、 index 、 rindex 、 count 、 startswith 、 endswith 。

（3）join（合并序列元素）

join 是一个非常重要的字符串方法，其作用与 split 相反，用于合并序列的元素。该方法能够在一组数据中增加分隔字符

#str.join(iter)
seq = ['1', '2', '3', '4', '5']
sep = '+'
print(sep.join(seq)) # 合并一个字符串列表
#'1+2+3+4+5'
print('+'.join(seq)) # 合并一个字符串列表
#'1+2+3+4+5'

print(' '.join('python'))
#p y t h o n

s='love'
r='-'.join(s)
print(r)
#l-o-v-e

参见： split 。

（4）lower（字符串小写化）

方法 lower 返回字符串的小写版本。

print('Trondheim Hammer Dance'.lower())
#'trondheim hammer dance'
#使用案例
name = 'Gumby'
names = ['gumby', 'smith', 'jones']
if name.lower() in names: print('Found it!')
#Found it!

参见： islower 、 istitle 、 isupper 、 translate 。
附： capitalize 、 casefold 、 swapcase 、 title 、 upper 。

（5）replace（字符串替换）

方法 replace 将指定字符串都替换为另一个字符串，并返回替换后的结果。

#str.replace(old,new)
print('This is a test'.replace('is', 'eez'))
#'Theez eez a test'
#replace去除字符串中的特定字符和字符串
print('python is an excellent language.'.replace('excellent',''))
#python is an  language.

参见：translate 。
附： expandtabs 。

（6）split（拆分序列元素）

split 是一个非常重要的字符串方法，其作用与 join 相反，用于将字符串拆分为序列。

print('1+2+3+4+5'.split('+'))
#['1', '2', '3', '4', '5']

#如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。
print('Using the default'.split())
#['Using', 'the', 'default']

s='i love china'
r=s.split(' ')
print(r)
#i love china

参见： join 。
附： partition 、 rpartition 、 rsplit 、 splitlines 。

（7）strip（删除字符串开头/末尾空白）

方法 strip 将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果。

print(' internal whitespace is kept '.strip())
#'internal whitespace is kept'
#在一个字符串参数中指定要删除哪些字符。
print('*** SPAM * for * everyone!!! ***'.strip(' *!'))
#'SPAM * for * everyone'

附： lstrip() 去左边空格 rstrip() 去右边空格 。

（8）translate（字符串替换）

方法 translate（可同时替换多个字符） 与 replace （单字符替换）一样替换字符串的特定部分。

使用 translate 前必须创建一个转换表，要创建转换表，可对字符串类型 str 调用方法 maketrans ，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符。

table = str.maketrans('cs', 'kz')
print('this is an incredible test'.translate(table))
#'thiz iz an inkredible tezt'

参见： replace 、 lower 。

（9）count

#str.count(sub)方法返回字符串str中出现sub的次数，sub是一个字符串
print('python is an excellent language.'.count('a'))
#3

（10）判断字符串是否满足特定的条件

判断字符串是否具有特定的性质（如包含的字符全为空白、数字或大写）。如果字符串具备特定的性质，这些方法就返回True ，否则返回 False 。
附： isalnum 、 isalpha 、 isdecimal 、 isdigit 、 isidentifier 、 islower 、 isnumeric 、isprintable 、 isspace 、 istitle 、 isupper 。

6 序列

有几种操作适用于所有序列，包括索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

索引

索引：访问单个元素

对于字符串字面量（以及其他的序列字面量），可直接对其执行索引操作，无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。

print('Hello'[1])
#'e' 

切片

切片（slicing）：访问特定范围内的元素
str.[开始位置：结束为止）-----左闭右开区间

（1）Python可切片对象的索引方式
包括：正索引和负索引两部分，如下图所示，以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：

（2） Python切片操作的一般方式
一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_index、step)。当只有一个“:”时，默认第三个参数step=1；当一个“:”也没有时，start_index=end_index，表示切取start_index指定的那个元素。

切片操作基本表达式：object[start_index:end_index:step]

start_index：表示起始索引（包含该索引对应值）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。

end_index：表示终止索引（不包含该索引对应值）；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定，step为正时直到“终点”，为负时直到“起点”。

step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以步长1取值。“切取方向非常重要！”“切取方向非常重要！”“切取方向非常重要！”，重要的事情说三遍！

（3）Python切片操作详细例子
以下示例均以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：
①切取单个元素

print(a[0])
#0
print(a[-4])
#6

②切取完整对象

print(a[:])#从左往右
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[::-1])#从右往左
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

③ start_index和end_index全为正（+）索引的情况

#step=1，从左往右取值，start_index=1到end_index=6同样表示从左往右取值。
print(a[1:6])
#[1, 2, 3, 4, 5]

#输出为空列表，说明没取到数据。step=-1，决定了从右往左取值，而start_index=1到end_index=6决定了从左往右取值，两者矛盾，所以为空。
print（a[1:6:-1]）
#[]

#同样输出为空列表。step=1，决定了从左往右取值，而start_index=6到end_index=2决定了从右往左取值，两者矛盾，所以为空。
print（a[6:2]）
# []

#step=1，表示从左往右取值，而start_index省略时，表示从端点开始，因此这里的端点是“起点”，即从“起点”值0开始一直取到end_index=6（该点不包括）。
print（a[:6]）
#[0, 1, 2, 3, 4, 5]

#step=-1，从右往左取值，而start_index省略时，表示从端点开始，因此这里的端点是“终点”，即从“终点”值9开始一直取到end_index=6（该点不包括）。
print(a[:6:-1])
# [9, 8, 7]

#step=-1，从右往左取值，从start_index=6开始，一直取到“起点”0。
print(a[6::-1])
#[6, 5, 4, 3, 2, 1, 0]

④ start_index和end_index全为负（-）索引的情况

#step=1，从左往右取值，而start_index=-1到end_index=-6决定了从右往左取值，两者矛盾，所以为空。
print(a[-1:-6])
# []

#step=-1，从右往左取值，start_index=-1到end_index=-6同样是从右往左取值。
print(a[-1:-6:-1])
# [9, 8, 7, 6, 5]

#step=-1，从右往左取值，从“终点”开始一直取到
print(a[:-6:-1])
#[9, 8, 7, 6, 5]

#step=1，从左往右取值，而start_index=-6到end_index=-1同样是从左往右取值。
print(a[-6:-1])
# [4, 5, 6, 7, 8]

⑤start_index和end_index正（+）负（-）混合索引的情况

#start_index=1在end_index=-6的左边，因此从左往右取值，而step=1同样决定了从左往右取值，因此结果正确
print(a[1:-6])
# [1, 2, 3]

#start_index=1在end_index=-6的左边，因此从左往右取值，但step=-则决定了从右往左取值，两者矛盾，因此为空。
print(a[1:-6:-1])
#[]

#start_index=-1在end_index=6的右边，因此从右往左取值，但step=1则决定了从左往右取值，两者矛盾，因此为空。
print（a[-1:6]）
# []

#start_index=-1在end_index=6的右边，因此从右往左取值，而step=-1同样决定了从右往左取值，因此结果正确。
print（a[-1:6:-1)
#[9, 8, 7]

⑥多层切片操作

#[-1:] 步长为1即从左往右取值理论上可无限次多层切片操作，只要上一次返回的是非空可切片对象即可。
#如下相当于：
#a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
#a[:8][2:5]= [2, 3, 4]
#a[:8][2:5][-1:] = [4]   
print(a[:8][2:5][-1:])
#[4]

⑦切片操作的三个参数可以用表达式

print(a[2+1:3*2:7%3])
#a[2+1:3*2:7%3] = a[3:6:1]
# [3, 4, 5]

⑧其他对象的切片操作
前面的切片操作以list对象为例进行说明，但实际上可进行切片操作的数据类型还有很多，包括元组、字符串等等。

#元组的切片操作
print( (0, 1, 2, 3, 4, 5)[:3])
#(0, 1, 2)

#字符串的切片操作
print('ABCDEFG'[::2])
#'ACEG'

#就是利用range()函数生成1-99的整数，然后从start_index=2（即3）开始以step=3取值，直到终点，再在新序列中取最后五个数。
for i in range(1,100)[2::3][-5:]: 
    print(i)
#87
#90
#93
#96
#99

（4） 常用切片操作
①取偶数位置

print(a[::2])
#[0, 2, 4, 6, 8]

②取奇数位置

print(a[1::2])
#[1, 3, 5, 7, 9]

③拷贝整个对象

b = a[:] #
print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(id(a)) #41946376
print(id(b)) #41921864

b = a.copy()
print(b) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(id(a)) #39783752
print(id(b)) #39759176

需要注意的是：[:]和.copy()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用方式共享，而非独立分配内存，如果需要彻底拷贝则需采用“深拷贝”方式，如下例所示：

a = [1,2,['A','B']]
print('a={}'.format(a))
b = a[:]
b[0] = 9 #修改b的最外层元素，将1变成9
b[2][0] = 'D' #修改b的内嵌层元素
print('a={}'.format(a))
print('b={}'.format(b))
print('id(a)={}'.format(id(a)))
print('id(b)={}'.format(id(b)))
#a=[1, 2, ['D', 'B']] #b修改内部元素A为D后，a中的A也变成了D，说明共享内部嵌套元素，但外部元素1没变。
#b=[9, 2, ['D', 'B']] #修改后的b
#id(a)=38669128
#id(b)=38669192

④修改单个元素

a[3] = ['A','B']
print([0, 1, 2, ['A', 'B'], 4, 5, 6, 7, 8, 9])

⑤在某个位置插入元素

a[3:3] = ['A','B','C']
print(a)
#[0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]

a[0:0] = ['A','B']
print(a)
#['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

⑥替换一部分元素

a[3:6] = ['A','B']
print(a)
#[0, 1, 2, 'A', 'B', 6, 7, 8, 9]

（5）注意：
①“取单个元素（不带“:”）”时，返回的是对象的某个元素，其类型由元素本身的类型决定，而与母对象无关，如上面的a[0]=0、a[-4]=6，元素0和6都是“数值型”，而母对象a却是“list”型；
②“取连续切片（带“:”）”时，返回结果的类型与母对象相同，哪怕切取的连续切片只包含一个元素，如上面的a[-1:]=[9]，返回的是一个只包含元素“9”的list，而非数值型“9”。

拼接（序列相加）

可使用加法运算符来拼接序列

print([1, 2, 3] + [4, 5, 6])
#[1, 2, 3, 4, 5, 6]

print('Hello,' + 'world!')
#'Hello, world!'

print([1, 2, 3] + 'world!')
#TypeError: can only concatenate list (not "string") to list
#从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。

乘法

将序列与数x相乘时，将重复这个序列x次来创建一个新序列

print([42] * 10)
#[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

print([None] * 10）
#[None, None, None, None, None, None, None, None, None, None]

成员资格

要检查特定的值是否包含在序列中，可使用运算符 in（not in)

对象

对象当中保存了三个数据：

• type(类型)
• id(标识)
• value(值)
  可变对象指的是对象里面的value可以被我们改变

6.1 列表（可变序列）

列表是一种序列，在序列中，每个元素都有编号。

6.1.1 类list(seq)

可将任何序列（字符串/元组）作为 list 的参数转换为列表
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

print(list('Hello'))
#输出['H', 'e', 'l', 'l', 'o']

6.1.2 基本的列表操作

(1)修改列表：给元素赋值
使用索引表示法给特定位置的元素赋值，如 x[1] = 2

x = [1, 1, 1]
x[1] = 2
print(x)
#输出x = [1, 2, 1]

(2) 删除元素
使用 del 语句删除列表中元素

names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
print(del names[2])
#输出names=['Alice', 'Beth', 'Dee-Dee', 'Earl']

(3) 给切片赋值
①通过使用切片赋值，可将切片替换为长度与其不同的序列:

name = list('Perl')
name[1:] = list('ython')
print(name)
# name=['P', 'y', 't', 'h', 'o', 'n']

②使用切片赋值还可在不替换原有元素的情况下插入新元素

 numbers = [1, 5]
 numbers[1:1] = [2, 3, 4]
 print(numbers)
 # numbers=[1, 2, 3, 4, 5]

③使用切片赋值删除元素

numbers=[1, 2, 3, 4, 5]
numbers[1:4] = []
print(numbers)
# numbers=[1, 5]

6.1.3 列表方法

方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：
object.method(arguments)
注：方法调用与函数调用很像，只是在方法名前加上了对象和句点。

(1) append（增加）

方法 append 用于将一个对象附加到列表末尾。

lst = [1, 2, 3]
print(lst.append(4))#同lst[3:3]=4
#lst=[1, 2, 3, 4]

(2) clear

lst = [1, 2, 3]
lst.clear()
 #lst=[]

这类似于切片赋值语句 lst[:] = []

(3) copy(浅复制）

方法 copy 复制列表，a 和 b 可指向不同的列表(浅复制：value相同，id不同）

a = [1, 2, 3]
b = a.copy()
b[1] = 4
print(a,b)
#[1, 2, 3] [1, 4, 3]

注：如下常规复制只是将另一个名称关联到列表,a 和 b 指向相同的列表

a = [1, 2, 3]
b = a
b[1] = 4
print(a,b)
#[1, 4, 3][1, 4, 3]

(4)count（元素复现次数）

方法 count 计算指定的元素在列表中出现了多少次。

x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
print(x.count(1))
# 2
print(x.count([1, 2]))
# 1

(5)extend（扩展）

方法 extend可使用一个列表来扩展另一个列表

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)#同a+=b
print(a)
#[1, 2, 3, 4, 5, 6]

获得与 extend 相同的效果，可将列表赋给切片，如下所示：

a = [1, 2, 3]
b = [4, 5, 6]
a[len(a):] = b
print(a)
#[1, 2, 3, 4, 5, 6]

(6)index（查找索引）

方法 index 在列表中查找指定值第一次出现的索引。
index()：第二个位置表示起始位置，第三个位置表示结束位置

knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
print(knights.index('who'))
# 4

(7)insert（增加）

insert(arg1,arg2) 像列表指定位置插入一个元素 参数1:要插入的位置 参数2:要插入的元素

方法 insert 用于将一个对象插入列表。

numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')
print(numbers)
#[1, 2, 3, 'four', 5, 6, 7]

与 extend 一样，也可使用切片赋值来获得与 insert 一样的效果。

numbers = [1, 2, 3, 5, 6, 7]
numbers[3:3] = ['four']
print(numbers)
#[1, 2, 3, 'four', 5, 6, 7]

(8)pop（删除-有返回值）

• 方法 pop 从列表中删除一个元素（末尾为最后一个元素），并返回这一元素。
• 使用 pop 可实现一种常见的数据结构——栈（stack）。栈就像一叠盘子，你可在上面添加盘子，还可从上面取走盘子。最后加入的盘子最先取走，这被称为后进先出（LIFO）。
• pop 是唯一既修改列表又返回一个非 None 值的列表方法。

x = [1, 2, 3]
print(x,x.pop())
#[1, 2] 3
x.pop(0)
print(x)
#[2]

(9) remove（删除-无返回值）

方法 remove 用于删除第一个为指定值的元素。

 x = ['to', 'be', 'or', 'not', 'to', 'be']
 x.remove('be')
 print(x)
 #['to', 'or', 'not', 'to', 'be']

注：remove 是就地修改且不返回值的方法之一。不同于 pop 的是，它修改列表，但不返回任何值。

(10)reverse

方法 reverse 按相反的顺序排列列表中的元素

x = [1, 2, 3]
x.reverse()
print(x)
#[3, 2, 1]

注： reverse 修改列表，但不返回任何值（与 remove 和 sort 等方法一样）。

(11)sort

方法 sort 用于对列表就地排序,默认为升序。

 x = [4, 6, 2, 1, 7, 9]
 x.sort()
 print(x)
#[1, 2, 4, 6, 7, 9]

方法 sort 接受两个可选参数： key 和 reverse 。

x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
x.sort(key=len)#根据长度升序
print(x)
#['add', 'acme', 'aerate', 'abalone', 'aardvark']

x = [4, 6, 2, 1, 7, 9]
x.sort(reverse=True)
print(x)
#[9, 7, 6, 4, 2, 1]
x.sort(reverse= False)
print(x)
#[1, 2, 4, 6, 7, 9]

(12)count

list.count(x) 统计指定元素在列表中出现的个数

6.1.4 遍历列表

• while的实现步骤原理
• for 循环的实现原理
• range()函数的特点以及和for循环的配合使用

'''
语法
for 变量 in 序列(遍历的规则):
    代码块
'''

6.2 元组(不可变序列)

元组是一种特殊的序列，类似于列表，只是不能修改（一旦创建，内容就是固定的）。元组的切片也是元组。

• 元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

#交互模式
In[1]:1, 2, 3
Out[1]:(1, 2, 3)

• 元组还可用圆括号括起（这也是通常采用的做法）。

print((1, 2, 3))
#(1, 2, 3)

空元组:

#交互模式
In[1]:()
Out[1]: ()

只包含一个值的元组:虽然只有一个值,也必须在它后面加上逗号

#交互模式
In[1]:42,
Out[1]:(42,)

#交互模式
In[1]:(42,)
Out[1]:(42,)

6.2.1类tuple（序列元组化）:

工作原理与 list 很像，它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

print(tuple([1, 2, 3]))
#(1, 2, 3)

print(tuple('abc'))
#('a', 'b', 'c')

print(tuple((1, 2, 3)))
#(1, 2, 3)

元组并不太复杂，而且除创建和访问其元素外，可对元组执行的操作不多。元组的创建及其元素的访问方式与其他序列相同。

#交互模式
In[1]: x = 1, 2, 3
In[2]: x[1]
Out[1]:2
In[3]:x[0:2]
Out[3]:(1, 2)

6.2.2元组的作用

• 用作映射中的键（以及集合的成员），而列表不行。
• 有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的 index 和 count等方法时例外）。

一般而言，使用列表足以满足对序列的需求。

6.2.3元组的解包

• 元组解包指将元组当中的每⼀个元素都赋值给⼀个变量
• 在对一个元组进行解包的时候，变量的数量需要和元祖中元素的数量保持一致
• 如果没有保持一致，我们可以在变量前面加上一个 *。这样变量就会获取元组中所有剩余的元素，并以列表的形式返回

7 字典(值可变）

• 字典是Python中唯一的内置映射类型，在映射中，每个元素都有名称（也叫键或key）（查询数据性能好）。
• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)

7.1字典的用途

下面是Python字典的一些用途：

• 表示棋盘的状态，其中每个键都是由坐标组成的元组；
• 存储文件修改时间，其中的键为文件名；
• 数字电话/地址簿。

7.2创建和使用字典

字典以类似于下面的方式表示：
phonebook = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}

字典由键及其相应的值组成，这种键-值对称为项（item）。在前面的示例中，键为名字，而值为电话号码。每个键与其值之间都用冒号（ : ）分隔，项之间用逗号分隔，而整个字典放在花括号内。空字典（没有任何项）用两个花括号表示，类似于下面这样： {} 。

注意： 在字典（以及其他映射类型）中，键必须是独一无二的，而字典中的值无需如此。

#字典的键最好不要重复，如果出现重复后边的会替换前面的
d = {'name':'葫芦娃','age':10,'sex':'男','name':'xxxx'}
print(d)
#{'name': 'xxxx', 'age': 10, 'sex': '男'}

7.2.1类 dict

可使用类 dict 从其他映射（如其他字典）或键-值对序列创建字典。

#交互模式
In[1]:items = [('name', 'Gumby'), ('age', 42)]
In[2]:d = dict(items)
Out[2]:d = {'age': 42, 'name': 'Gumby'}
In[3]:d['name']
Out[3]:'Gumby'
#使用关键字实参来调用函数
In[4]:d = dict(name='Gumby', age=42)
Out[4]:d = {'age': 42, 'name': 'Gumby'}

7.2.2基本的字典操作

字典的基本行为在很多方面都类似于序列：

• len(d) 返回字典 d 包含的项（键-值对）数。
• d[k] 返回与键 k 相关联的值。
• d[k] = v 将值 v 关联到键 k 。
• del d[k] 删除键为 k 的项。
• k in d 检查字典 d 是否包含键为 k 的项。

字典和列表的一些重要不同之处：

• 键的类型：字典中的键可以是任何不可变的类型，如整数、浮点数（实数）、字符串或元组。
• 自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用 append 或其他类似的方法，就不能给列表中没有的元素赋值。

#列表
In(1):x = []
In(2):x[42] = 'Foobar'
In(3):print(x)
Out(3):IndexError: list assignment index out of range
#字典
In(1):x = {}
In(2):x[42] = 'Foobar'
In(3):print(x)
Out(3):{42: 'Foobar'}

• 成员资格：表达式 k in d （其中 d 是一个字典）查找的是键而不是值，而表达式 v in l （其中 l 是一个列表）查找的是值而不是索引。这看似不太一致，但你习惯后就会觉得相当自然。毕竟如果字典包含指定的键，检查相应的值就很容易。

a = {'name':'python','data':{'result':[{'src':'python1'},{'src':'python2'},{'src':'python3'}]}}
b = a['data'] # :{'result':[{'src':'python1'},{'src':'python2'},{'src':'python3'}]}
d = b['result'] # [{'src':'python1'},{'src':'python2'},{'src':'python3'}]
for k in d:
    print(k,k['src'])
'''
{'src': 'python1'} python1
{'src': 'python2'} python2
{'src': 'python3'} python3
'''

7.2.3将字符串格式设置功能用于字典

要对字典执行字符串格式设置操作，不能使用 format和命名参数，而必须使用 format_map 。

phonebook={'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
print("Cecil's phone number is {Cecil}.".format_map(phonebook))
#"Cecil's phone number is 3258."

7.2.4字典方法

7.2.4.1clear（删除全部）

方法 clear 删除所有的字典项，这种操作是就地执行的（就像 list.sort 一样），因此什么都不返回（或者说返回 None ）。

d = {'age': 42, 'name': 'Gumby'}
returned_value = d.clear()
print(d)
#{}
print(returned_value)
#None

7.2.4.2copy(浅复制)

• 方法 copy 返回一个新字典（新id）,字典为副本
• 方法 copy 其包含的键-值对与原来的字典相同,值本身是原件（非复制）
• 浅复制只复制字典本身，如果字典中还有个字典是不会进⾏复制的（浅拷贝只能拷贝出来对象的第一层数据，不能拷贝对象的更深层数据）

x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
y = x.copy()
y['username'] = 'mlh'#当替换副本中的值时，原件不受影响
y['machines'].remove('bar')#修改副本中的值（就地修改而不是替换），原件也将发生变化
print(y)
#{'username': 'mlh', 'machines': ['foo', 'baz']}
print(x)
#{'username': 'admin', 'machines': ['foo', 'baz']}

附：deepcopy（深复制）

7.2.4.3fromkeys（创建新字典）

方法 fromkeys 创建一个新字典，其中包含指定的键，且每个键对应的值都是 None 。

print(dict.fromkeys(['name', 'age']))
#{'age': None, 'name': None}

#如果你不想使用默认值 None ，可提供特定的值。
print( dict.fromkeys(['name', 'age'], '(unknown)'))
#{'age': '(unknown)', 'name': '(unknown)'}

7.2.4.4get（取值）

方法 get 为访问字典项提供了宽松的环境。
型式：get(key,[default])

#通常，如果你试图访问字典中没有的项，将引发错误。
d = {}
print(d['name'])
#KeyError: 'name'

#使用get来访问不存在的键时，没有引发异常，而是返回 None。
print(d.get('name')
#None

#指定“默认”值，这样将返回你指定的值而不是None 。
print(d.get('name', 'N/A'))
#'N/A'

#字典包含指定的键， get的作用将与普通字典查找相同。
d['name'] = 'Eric'
print(d.get('name')
#'Eric'

7.2.4.5 pop（删除）

方法 pop 可用于获取与指定键相关联的值，并将该键-值对从字典中删除。
d.pop(key,default),如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.pop('name')#删除键值对
print(pop_obj) 
#菜鸟教程
print(site) 
#{'alexa': 10000, 'url': 'www.runoob.com'}

7.2.4.6 update（赋值）

• 描述：Python 字典(Dictionary) update() 函数把字典dict2的键/值对更新到dict里。
• 语法：dict.update(dict2)
• 参数：dict2 – 添加到指定字典dict里的字典
• 返回值：该方法没有任何返回值。
• 实例

dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print("Value : %s" % dict)
#Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

#如果有重复的key，后边会覆盖前面的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6,'a':7}
d.update(d2)
print(d)
#{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

7.2.4.7 popitem（随机删除）

• popitem() 随机删除字典中的一个Key-Value。一般都会删除最后一个键值对
• 删除之后会把删除的k-v作为返回值返回

d = {'a':1,'b':2,'c':3}
# 第一次运行
d.popitem()
print(d)
# 第二次运行
d.popitem()
print(d)
# 第三次运行
d.popitem()
print(d)

#运行结果：
''''''
{'a': 1, 'b': 2}
{'a': 1}
{}
''''''

7.2.4.8 setdefault（取值）

• 描述
  Python 字典 setdefault() 函数和 get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
• 语法
  dict.setdefault(key, default=None)
• 参数
  key – 查找的键值。
  default – 键不存在时，设置的默认键值。
• 返回值
  如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}
 
print("Value : %s" %  dict.setdefault('runoob', None))
print("Value : %s" %  dict.setdefault('Taobao', '淘宝'))
#输出结果：
'''
Value : 菜鸟教程
Value : 淘宝
'''

7.2.5 遍历字典（keys values items）

我们主要可以通过3种方式对字典进行遍历

• keys() 该方法返回字典所有的key
  方法 keys 返回一个字典视图，其中包含指定字典中的键。

dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" %  dict.keys())
#Value : ['Age', 'Name']

• values() 该方法返回⼀个序列 序列中保存有字典的值
  不同于方法 keys ，方法 values 返回的视图可能包含重复的值。

d = {}
d[1] = 1
d[2] = 2
d[3] = 3
d[4] = 1
print(d.values())
#dict_values([1, 2, 3, 1])

• items() 该方法会返回字典中所有的项，它返回⼀个序列，序列中包含有双值子序列，双值分别是字典中的key和value
  其中每个元素都为 (key, value) 的形式
  字典项在列表中的排列顺序不确定
  返回值属于一种名为字典视图的特殊类型(字典视图可用于迭代,还可确定其长度以及对其执行成员资格检查)。

d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}
print(d.items())
#dict_items([('url', 'http://www.python.org'), ('spam', 0), ('title', 'Python Web Site')])

8 集合（set）

8.1集合简介

集合表现形式set 集合和列表非常相似，不同点如下：
①集合只能存储不可变对象
②集合中存储的对象是无序的(不是按照元素的插入顺序保存的)
③集合不能出现重复元素

• 使用{}来创建集合
• 可以通过set()来将序列和字典转换成集合

# 如果使用set()将字典转换为集合的时候，只会包含字典的键
s = set({'a':1,'b':2,'c':3})
print(s)
#{'c', 'a', 'b'}

• 集合类型主要用于元素去重，适合于任何组合数据类型

S=set('知之为知之不知为不知')
for i in S:
    print(i,end='')
 #输出结果：知为之不

• len() 使用len()来获取集合中元素的数量
• add()向集合中添加元素
• update()将⼀个集合中的元素添加到另⼀个集合当中
• pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
• remove() 删除集合中指定的元素
• clear() 清空集合

8.2 集合的运算

• （ & ）交集运算：
  返回一新集合，包括同时在集合S和集合T中的元素

• （ | ）并集运算：
  返回一新集合，包括集合S和集合T中的所有元素

• （ —）差集运算
  返回一新集合，包括在集合S中但不在集合T中的所有元素

• （^ ）亦或集
  返回一新集合，包括集合S和集合T中的非共同元素

• （<= ）检查⼀个集合是否是另⼀个集合的子集

• （< ）检查⼀个集合是否是另⼀个集合的真⼦集

• （>=）检查⼀个集合是否是另⼀个集合的超集

• （>）检查⼀个集合是否是另⼀个集合的真超集

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

print(s,s2)
#& 交集运算
r = s & s2  {3, 4, 5}

#| 并集运算
r = s | s2  {1, 2, 3, 4, 5, 6, 7}

#- 差集运算
r = s - s2
r = s2 - s # {6, 7}

#^ 亦或集
r = s ^ s2 {1, 2, 6, 7}
r = s2 ^ s

9 Bytes类型

9.1 bytes介绍

• 在Python3以后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。
• bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。
• Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。

9.2 bytes创建

可以通过调用bytes()生成bytes实例，其值形式为 b’xxxxx’，对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

a = b'hello'
print(type(a))
#<class 'bytes'>
b = bytes('hello',encoding='utf8')
print(type(b))
#<class 'bytes'>

9.3 bytes类型常用转换

• 字节转为字符串

d = b'world'
print(d.decode())
#'world'
print(type(d))
#<class 'bytes'>

• 字符串转为字节

e = 'world'
print(e.encode())
#b'world'
print(type(e))
#<class 'str'>

10 数据类型判断

int float bool complex str list tuple set dict

#法一：
res=isinstance(5,int)
print(res)
#True

#法二：
var='lab'
res=isinstance(var,(int,str,list))
print(res)
#True