Python的核心数据类型

1、数字

Python中的数字类型包括：整型 int、布尔型bool（继承自整型 int）、浮点型 float、复数 complex

1.1 整型 int

1） 定义：整型数是不带有小数部分的数据，包括自然数，负数           eg：0  256  -65536
2） 整型字面值的表示方式：
    十进制表示：10 20 3000 400  -5000   9999999999
    八进制表示方式：0o开头（数字零，英文字母o），后跟 0~7    例如：0o177（十进制：127）   0o11（十进制：9）
    十六进制表示方式：0x开头（数字零，英文字母x），后跟0~9，a~f或A~F，a=10，f=15    0x11（十进制：17）
    二进制表示方式：0b开头（数字0，英文字母b），后跟0~1    例如：0b1010（十进制：10）
3） 进制说明：
    我们日常生活中用到最多的就是十进制，十进制也是我们最熟悉的数字的表现形式。而计算机只能识别二进制。另外常用的还有上述的八进制、十六进制等很多种进制方式，应用领域不同，采取的进制也就不同。不过计算方法都是大同小异：
    1）二进制：逢二进一 （0-1）：0 1 10 11 100 101 110 111 1000（分别对应十进制 0~8）
    2）八进制：逢八进一 （0-7）：0 1 2 3 4 5 6 7 10 11 12（分别对应十进制 0~10）
    3）十进制：逢十进一 （0-9） ：0 1 2 3 4 5 6 7 8 9 10（我们最熟悉的）
    4）十六进制：逢十六进一 （0-9，a-f，A-F）:0 1 2 3 4 5 6 7 8 9 a b c d e f 10（分别对应十进制 0~16）
4） 十进制科学计数法：科学记数法是一种记数的方法。把一个数表示成a（1≤a<10，n为整数）与10的幂相乘的形式，这种记数法叫做科学记数法。当我们要标记或运算某个较大或较小且位数较多时，用科学记数法免去浪费很多空间和时间。
    例如：65553600000=1.99714×10^13。计算器或电脑表达10的幂是一般是用E或e，也就是1.99714E10或者1.99714×10e10
5） 二进制也有科学计数法，举例说明
    ------------------------------------------------------------------------
    1101.0011=11010011*2(-100) 其中-100表示2的指数，-100（二进制）=-4（十进制）
    1101.0011=0.11010011*2(+100) 其中+100表示2的指数，+100=+4
    ------------------------------------------------------------------------
6） 任何一个r进制数N都可以写成（N）r=(+/-)S*r(+/-e)这种科学计数法
    其中N表示需要表示的数，r表示进制，S表示尾数，N的有效位数字，e表示阶码，代表小数点的位置

1.2浮点型数 float

1） 定义：浮点型数是带有小数点部分的数字（小数部分可以是0）
2） 浮点型表示方式： 
      小数形式 3.14 3.22
      科学记数法
          格式：小数e/E（正负号）指数
          例如：6.18E-1  =  0.618    2.9979e8  =  299790000    
3） 注意：在我们的Python中，浮点型计算采用了不完善的机制，可能导致损失精度，在我们日常编程当中应该注意，尽量使用格式化输出方式：
    例如：
    ------------------------------------
    >>> print((2.3*7))        16.099999999999998
    >>> print(2.6*7)          18.2
    >>> print('%.2f'%(2.3*7)) 16.10
    >>> print('%.2f'%(2.6*7)) 18.20
    ------------------------------------
    在Python中还可以用引入小数（Decimal）、分数（Fraction）形式避免浮点数精度损失，再次就不加赘述了

1.3 复数 complex

1.3.1 复述分为两部分：
      实部（real）
      虚部（image）
   注意：虚部是以 j或J结尾的
   例如：1+2j   （2J） 3-4J

1.4 布尔型数：

1.4.1 布尔型数通常用来表示真和假两种状态的类型
    True表示真 值为1 满足条件成立
    False表示假    值为0 条件不满足或者不成立
    ------------------------------------
    例如：   >>>True+True+True    # 3
            >>>True * 5      # 5    
    ------------------------------------

2、空值 None

• None是一个表示不存在的特殊对象 。
• 表示该值是一个空对象，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。你可以将None赋值给任何变量，也可以将任何变量赋值给一个None值得对象
• 作用：
  用来占位
  变量解除绑定

3、字符串 str

Python中有三种常用序列：分别是 ：字符串、列表、元组。字符串和元组皆为不可变序列，而列表为可变序列。以下是它们共同的特点 ：

1） 可以使用成员操作符(in/not in)来判断元素是否在序列中 
2） 通过索引获取一个元素     例如：a = 'abcd'   a[0]: 'a'   a[1] :'b'  注：超过索引值会报错！
3） 通过切片获取一组元素     例如：a = 'abcd'   a[0:2]: 'ab'  a[:3]: 'abd'  a[::-1](取反):'dcba'
4） *一个数字 可以让数组中的元素重复n次     例如：a = 'abcd'  print(a*2) : 输出：'abcdabcd'
5） 同类型的序列可以通过+来进行拼接     例如：a = 'abcd'  b = 'efgh'  a+b:'abcdefgh'
6） 通过len()获取序列长度     例如：a = 'abcd'    len(a) : 4
7） 序列都是可迭代对象    例如：for i in a:print(i,end = ' '):  a b c d 

下面介绍三种序列之一的字符串：

3.1 作用：

用来记录文字信息

3.2表示方法：

在非注释中，凡是用引号（''  ""   '''   """）括起来的部分都是字符串

3.3 空字符串的字面值得表示方式：

''
"" 
''''''
""""""
注：空字符串的布尔测试值bool(x)为False
   定义字符串的时候，用单引号''，或者双引号""，定义的结果是相同的。

3.4 非空字符串的字面值得表示方式：

'Python'
"Python" 
'''Python'''
"""Python"""

3.5 单引号和双引号的区别

1）单引号内的双引号不算结束符
2）双引号内的单引号不算结束符
示例：
    ------------------------------------
    print("I'’m a boy")   >>>I'm a boy
    ------------------------------------

3.6 三引号字符串

以 '''  或者  """  开头或结尾的字符串
作用：
    1）三引号字符串中的换行会自动转换为换行符'\n'
    2）三引号内可以包含单引号和双引号
示例：
    ------------------------------------
    '''
    我爱北京天安门
    天安门上太阳升         # 以编辑内容的原格式原输出，保留回车，单双引号等
    '''
    ------------------------------------

3.7隐式字符串的字面值拼接：

举例说明：
    ------------------------------------
    "Iam Student."  'And I am a boy'
    >>> I am Student. And I am a boy
    ------------------------------------

3.8用转义序列代表特殊字节

1）反斜杠用来引入特殊的字节编码，是转义序列
例如：
    ------------------------------------
    >>> s = 'a\nb\tc'    # \n  \t  见下表
    >>> s
    'a\nb\tc'
    >>> print(s)
    a
    b   c
    >>> len(s)
    5
    ------------------------------------
2）字符串反斜杠字符
转义   意义
------------------------------------
\newline    忽视（连续）
\\  反斜杠（保留\）  常用于存储文件路径。
\'  单引号（保留'）
\"  双引号（保留"）
\b  倒退
\f  换页
\n  换行
\r  返回
\t  水平制表符
\v  垂直制表符
\N{id}  Unicode数据库ID
\uhhhh  Unicode16位的十六进制值
\uhhhhhhhh  Unicode32位的十六进制值
\xhh    十六进制值
\ooo    八进制值
\0  Null(不是字符串结尾)
\other  不转义（保留）

3.9 raw 字符串（原始字符串）

1）格式：
---------------
r"字符串内容"
r'字符串内容'
r'''字符串内容'''
r"""字符串内容"""
---------------
2）作用：
让转义字符无效，一般用在字符串存储文件路径时，防止转义带来的不安全隐患。
3）例如：
a = r"C:\newfile\text.py ：取消其中的 \n  \t   转义，以保证存储正确的文件路径
等同于a = 'C:\\newfile\\text.py'

3.10 字符串的运算：

运算符： + += * *=
-----------------------
+   加号运算符用于拼接字符串
+=  用于拼接运算后改变原变量的绑定关系
*   生成重复的字符串        注：字符串只能和整数相乘
*=  生成重复的字符串并且改变原来的变量的绑定关系

3.11 字符串的比较操作

运算符： < <= > >= == !=
示例：
--------------------
'A'<'B'     True        根据编码值进行比较
'ba'>'ab'   True
'a'<'ab'    True
'ad'>'abc'  True        从前到后进行比较，符合比较运算符即为 True
--------------------    

3.12 in / not in 运算符

1)作用：   用于序列，字典，集合中，用于判断某个值是否存在于容器中，存在返回True，不存在返回False
2)说明：   not in 与 in 返回结果相反
3) 格式： 对象 in 序列
示例：
-------------------------
x='welcome to China!'
'to' in x   ：True
'e t' in x  ：True
'hello' in x    ：False
'hello' not in x    ：True
-------------------------

3.13 索引操作 index
python 字符串是不可改变的序列，所有的序列都可以通过索引来获取其中的元素

1）语法：   字符串[索引整数]
2）说明：
    a.序列的正向索引是从0开始的，第二个索引为1，最后一个为 len(s)-1（==-1）
    b.序列的反向索引是从-1 开始的，-1代表最后一个，-2代表倒2，以此类推，第一个是-len(s)
示例：
--------------------------------
s = 'ABCDE'
s[0]    # A
s[-1]   # E
--------------------------------    

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

1)语法：s[(开始索引):(结束索引)(:(步长s))]     注：小括号部分可省略
2)说明：
    a.开始索引是切片切下的位置，0代表第一个元素,-1代表最后一个元素
    b.结束索引是切片的终止索引（但不包含终止点）
    c.步长是切片每次获取完当前的元素后移动方向和偏移量
        3.1)没有步长，默认记为1
        3.2)当步长取正整数时，取正向切片，开始索引默认为0，结束索引为最后一个元素的下一个位置
        3.3)当步长为负数时，取反向切片，默认位置为最后一个元素，终止位置是第一个元素的前一个位置
示例:
--------------------------------------
s = 'ABCDE'
s[1:4]     >>>BCD
s[:-1]     >>>ABCD
--------------------------------------

3.15 python3中能用于字符串的函数：

len(x): 返回字符串的长度
max(x): 返回字符串编码中的最大值
min(x): 返回最小值
示例：
-----------------
s='Hello'
len(s) = 5
max(s) = 'o'
min(s) = H'
-----------------

3.16 字符串的编码转换函数：

ord(c): 返回一个字符c的Unicode编码值
chr(i): 返回i这个值对应的字符
示例：
--------------------
print(ord('A'))     # 65
print(chr(65))      # A
print(ord('中')) # 20013
print(chr(2345))    # '?'
--------------------

3.17 整数转字符串的函数：

bin(i)： 将整数转为二进制字符串
oct(i)： 将整数转为八进制字符串
hex(i)： 将整数转为十六进制字符串

3.18 字符串的构造函数：

str(obj='')     将对象转换为字符串
例如：
-------------------------
a = 16
print(str(a))    >>> '16'
-------------------------

3.19 python3 中常用的字符串方法（method）

1）方法的调用语法： 对象名.方法名(方法参数)
示例：
--------------------------------------------------
'abc'.isalpha()     # True判断'abc'是否为字母
132.isalpha()       # 报错,因为整型int没有isalpha()方法
print('123'.isalpha())  # False    # 因为字符串中的内容全为数字
2）字符串常用方法：
S.isdigit()                 判断字符串中的字符是否全为数字
S.isalpha()                 判断字符串是否全为英文字母
S.islower()                 判断字符串所有字符是否全为小写英文字母
S.isupper()                 判断字符串所有字符是否全为大写英文字母
S.isspace()                 判断字符串是否全为空白字符
S.center(width[,fill])          将原字符串居中，左右默认填充空格
S.count(sub[, start[,end]])         获取一个字符串中子串的个数
S.find(sub[, start[,end]])      获取字符串中子串sub的索引,失败返回-1
S.strip([chars])            返回去掉左右char字符的字符串(默认char为空白字符)
S.lstrip([chars])           返回去掉左侧char字符的字符串(默认char为空白字符)
S.rstrip([chars])           返回去掉右侧char字符的字符串(默认char为空白字符)
S.upper()               生成将英文转换为大写的字符串
S.lower()               生成将英文转换为小写的字符串
S.replace(old, new[, count])        将原字符串的old用new代替，生成一个新的字符串,count表示替换的个数，默认为全部替换
S.startswith(prefix[, start[, end]])    返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False
S.endswith(suffix[, start[, end]])  返回S是否是以suffix结尾，如果以suffix结尾返回True,否则返回False
4）以下是不常用的方法 
S.title()               生成每个英文单词的首字母大写字符串
S.isnumeric()               判断字符串是否全为数字字符 （与 isdigit()相同）
    例如：  >>> c.isnumeric() == c.isdigit()  ： True

3.20 字符串格式化表达式：

1）作用：生成一定格式的字符串
2）运算符：  %
3）语法格式： 格式字符串 % 参数值  或者 格式字符串 % （参数值1，参数值2，...）
4）说明：
    % 左侧为格式字符串
    % 右侧为参数值，当有多个参数值时 需要用括号()括起来，并用（,）分隔
5)格式化字符串中以 % 开头的为占位符号，占位符的位置用参数值替换

示例：
    fmt = "name:%s,age:%d"
    print(fmt %("张三",30))   # name:张三,age:30

3.21 格式化字符串中的占位符和类型码：

%s  字符串，使用str(x) 将x转换为字符串
%r  字符串，使用repr(x)将x转换为字符串   
%c  将整数转为单个字符串      # 相当于 chr() 转换
%d  转为十进制整数
%o  转为八进制整数
%x  十六进制整数
%X  十六进制整数
%e  指数型浮点数(e)
%E  指数型浮点数(E)
%f，%F   浮点数
%g，%G   十进制浮点数或指数浮点自动转换
%%  等同于一个%字符            # "%d%%"%95 >>>95%

3.22 占位符和类型码之间的格式化语法：

%[- + 0 宽度.精度] 型码
-----------------------------------
- ： 左对齐
+ ： 显示正号
0 ： 左侧空白位置补0
宽度： 整个字符串的字符个数
精度： 保留小数点后多少位（默认6位）
-----------------------------------
示例：
    ------------------------------------
    "%10d"%123      # '       123'
    "%-10d"%123     # '123       '
    "%10s"%'abc'    # '       abc'
    "%-10s"%'abc'   # 'abc       '
    "%010d"%123     # '0000000123'
    "%7.3f"%3.1415  # '3.141'
    "%07.2f"%1.1415 # '0003.14'
    -----------------------------------

4、列表

4.1列表的定义：

列表是一种容器
列表是可以被改变的序列
列表是由一系列特定元素组成的，元素与元素之间可能没有任何的关联关系，但他们有先后顺序的关系

4.2 创建空列表的字面值表达式

1） []       # 创建一个空列表
2） L = []   # L 变量绑定一个新创建的空列表

4.3 创建非空字面值得表达式：

L= [1,2,3,4]    # L绑定一个新创建的且含有四个元素的列表
L= [1,'a',3.14,'你好']  # 同上

4.4 列表的构造函数 list

1） list()   生成一个空的列表  等同于[]
2） list(iterable)   用可迭代对象创建一个列表
示例：
L = list()          # L=[]
L = list("hello")   # L = ['h','w','l','l','o']  # 字符串为可迭代对象
L = list(range(5))  # L = [0,1,2,3,4]            # range()函数返回可迭代对象

4.5 列表的运算：

1)算术运算：     + += * *= （运算规则于字符串的运算规则相同）
+：用于拼接列表，生成新的列表
    z = [1,2,3] + [4,5,6]   : z = [1,2,3,4,5,6]
+=：用原列表与右侧可迭代对象追加来修改原列表
    语法：
    列表变量 += 可迭代对象
    示例：x = [1,2,3]+=[4,5,6] :x =  [1,2,3,4,5,6]

+=：列表是可改变的变量，改变原来的列表对象，但是不改变列表地址，并不会创建新的列表
*：生成重复的列表
    x=[1]   x*2=[1,1]
*=：生成重复的列表，并改变对变量的绑定
    x=[1]   x*=3   x=[1,1,1]

4.6 列表的比较运算：

> >= < <= == != 
比较规则与字符串的相同
注：比较的时候，根据第一个决定胜负。也就是比较列表的第一个元素。大则大，小则小

4.7 列表是可迭代对象：

for i in [1,3,5,7]:
    print(i,end = '')   : 1 3 5 7

4.8 列表的 in / not in 运算符

1)判断一个值是否存在于列表中，如果存在返回True,否则返回 False
2)同字符串的 in 运算符 用于检查一个值是否存在于列表中，如果存在返回True, 否则返回False
示例:
----------------------------
x = [1, 'Two', 3, '四']
3 in x       # 返回 True
'3' in x     # 返回 False
10 in x      # False
10 not in x  # True

4.9 列表的索引操作

1)语法: 列表[整数表达式]
2)用法: 与字符串索引的用法相同(分为正向索引和反向索引)
示例:
----------------------------
x = [1,3,5,7]
print(x[1])   # 3　　
print(x[-1])  # 7

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

1）语法:  列表[整数表达式] = 表达式
2）作用:  改变列表中索引的绑定关系
示例:
----------------------------
x = [1, 2, 3, 4]    
x[2] = 3.14  # 改变了第三个元素的值
此时： x = [1,2,3.14,4]

4.11 列表的切片

列表[开始索引:结束索引]
列表[开始索引:结束索引:步长]
列表的切片取值返回一个新的列表，规则等同于字符串切片规则
示例:
----------------------------
x = [1, 2, 3, 4, 5, 6, 7, 8]
x[::2]      # [1, 3, 5, 7]
y = [1::3]  # y = [2, 5, 8]

4.12 列表的切片赋值:

1）作用:
    可以改变原列表的数据排列，可以插入和修改数据
    可以用切片改变列表的对应元素的值
2）语法:   
    列表[切片]　= 可迭代对象

3）说明:
    切片赋值的赋值运算符(=) 的右侧必须是一个可迭代对象
示例:
--------------------------------------------------------
L = [2, 3, 4]
L[0:1] = [1.1, 2.2]      # L = [1.1, 2.2, 3, 4]
L[2:] = [3.3, 4.4, 5.5]  # L = [1.1, 2.2, 3.3, 4.4, 5.5]
L[:] = [3, 4] 　         # L = [3, 4]
L[0:0] = [1, 2]          # L = [1, 2, 3, 4]
L = [3, 4]
L[1:1] = [3.14]          # L = [3, 3.14, 4]
L = [3, 4]
L[-1:-1] = [5, 6]        # L = [3, 4, 5, 6]
L = [2, 3, 4]
L[1:2] = "ABC"           # L = [2, 'A', 'B', 'C', 4]
L = [2, -1, 7]
L[1:2] = range(3, 7)     # L=[2, 3, 4, 5, 6, 7]
--------------------------------------------------------
4）切片的注意事项:
    对于步长不等于1的切片赋值,赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
示例:
--------------------------------------------------------
L = [1, 2, 3, 4, 5, 6, 7, 8]
L[1::2] = "ABCD"    # 对的    # L= [1,A,2,B,2,C,3,D]
L[1::2] = "ABCDEF"  # 错的    # 越界

4.13 del 语句
用于删除列表的元素

语法:
    del 列表[索引]  如: del L[0]
    del 列表[切片]    如: del L[1::2]

4.14 python 3中常用于序列的函数

len(s)  返回序列的长度
max(x)  返回序列的最大值元素
min(x)  返回序列的最小值元素
sum(x)  返回列中所有元素的和(元素必须是数值类型)
any(x)  真值测试,如果列表中其中一个值为真值则返回True
all(x)  真值测试,如果列表中所有值为真值返回True
示例:
----------------------------
L = [3, 1, 9, 7, 5]
print(len(L))  # 5
print(max(L))  # 9
print(min(L))  # 1
print(sum(L))  # 25

4.15 python3中常用的列表方法

list.append(obj)             向列表中添加一个对象obj
list.count(obj)              返回一个对象obj在列表中出现的次数
list.extend(seq)             把序列seq的内容添加到列表中
list.index(obj, i=0, j=len(list))    返回 list[k] == obj 的 k 值,并且 k 的范围在 i<=k<j;否则引发 ValueError 异常。
list.insert(index, obj)      在索引量为 index 的位置插入对象obj
list.pop(index=-1)           删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj)             从列表中删除找到的第一个obj对象，如果不存在则返回一个ValueError错误。

4.16 深拷贝和浅拷贝

1）浅拷贝 shallow copy
    浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
例如：
--------------------------------------
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy()  # 浅拷贝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.14, 3.2]]
print(L2)  # [1, 2, [3.14, 3.2]]
--------------------------------------  
2）深拷贝 deep copy
复制对象及对象关联的对象一起复制过程叫深拷贝
例如：
--------------------------------------
import copy  # 导入复制模块
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) 　# 深拷贝
print(L1)  # [1, 2, [3.1, 3.2]]
print(L2)  # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1)  # [1, 2, [3.1, 3.2]]　　
print(L2)  # [1, 2, [3.14, 3.2]]
--------------------------------------
　

4.17 列表和字符串比较：

1）都是序列，有先后顺序关系，有相同的运算操作
2）列表是可变是，字符串是不可变的
3）列表可以存任意类型的数据，字符串只能存字符

4.18 列表推导式
列表推导式是用可迭代对象创建列表的表达式

1）作用:  用简易方法生成列表
2）语法:  [表达式 for 变量 in 可迭代对象]    或   [表达式 for 变量 in 可迭代对象 if 真值表达式]
示例1:生成一个数值为1~9的平方的列表： [1, 4, 9, 16, .... 81]
----------------------------------------------------------------------------
不用推导式:
L = []
for i in range(1, 10):
L.append(i**2)
推导式实现：
L = [i ** 2 for i in range(1, 10)]
----------------------------------------------------------------------------    
示例2：用列表推导式生成 1~100以内奇数的列表：[1, 3, 5, 7, ...., 99]
--------------------------------------
[i for i in range(1, 100, 2)]
或者
[i for i in range(1, 100) if i % 2 == 1]

4.19 列表推导式的嵌套

语法:
    [ 表达式       for 变量1 in 可迭代对象1 if真值表达式1      for 变量2 in 可迭代对象2 if 真值表达式2 ]
示例：将列表[10, 20, 30] 中的元素与列表[1,2,3]元素分别相加,将得到的元素放于一个列表中
----------------------------------------------------------------------------
L = [x + y  for x in [10, 20, 30]  for y in [1,2,3]]
print(L)  #[11, 12, 13, 21, 22, 23, 31,32,33]

5、元组

元组是不可改变的序列。但同列表一样的是：元组可以存放任意类型的元素
元组一但创建将不可改变

5.1元组的表示方式：

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

5.2 创建空元组的字面值表达式

t = ()    # () 是创建一个空的元组对象

5.3 创建非空元组的字面值表达式：

t = 200,
t = (20,)
t = (1, 2, 3)
t = 100, 200, 300

5.4 元组的构造函数 tuple

1)tuple() 生成一个空的元组　，等同于()
2)tuple(iterable)  用可迭代对象生成一个元组
示例:
    t = tuple()
    t = tuple("ABC")
    t = tuple(range(1, 10, 2))

5.5 元组的运算：

+  用于用拼接方式创建一个新的元组
*  用于生成新的重复的元组
例如：
-----------------------------------------------
t = (1,2,3)  + (4, 5, 6)        # t = (1,2,3,4,5,6)
t += (7,8,9)                    # t = (1,2,3,4,5,6,7,8,9)
t = (1,2) * 3                   # t = (1,2,1,2,1,2)
t *= 4                          # t = (1,2,1,2,1,2,1,2)

5.6 列表的比较运算：

< <= > >= == !=  规则与列表的比较规则完全相同

5.7 元组的in / not in 运算符

用于判断元素是否存在于元组中,规则写列表完全相同

5.8 索引　index

用法等于同列表的索引
但是因为元组是不变序列，所以不支持索引赋值

5.9 切片

用法与列表的切片用法相同
元组的切片返回一个新的元组
同样，元组不能切片赋值，原因与索引相同

5.10 元组的方法：

T.index(v[,begin[,end]])  返回对应元素的索引下标， begin 为开始索引，end为结束索引，当v不存在时触发ValueError错误
T.count(x)                返回元组中对应的元素个数

6、字典

6.1 什么是字典：

1)字典是一种可变的容器，可以存储任意类型的数据
2)字典中的每个数据都是用'键'(key)进行索引的，而不像序列可以用索引下标进行索引
3)字典中的数据没有先后顺序关系,字典的存储是无序的
4)字典中的数据以键-值对(key-value)对形式进行映射存储
5)字典的键不能重复,且只能用不可变类型作为字典的键

6.2 字典的字面值表示方法：

以{} 括起来,以冒号(:) 分隔键-值对,各键值对用逗号分隔开

6.3创建空字典：

d = {}     # {} 表达式用来创建一个空的字典

6.4 创建非空字典：

d = {'name': 'weimingze', 'age': 35}
d = {'a': 100}
d = {'a': tuple("ABC")}
d = {'abc': list("ABC")}
d = {'a': {'b':100, 'c':200}}
d = {True:'真值', False: '假值', None:'空', 100:'一百'}
d = {(1970, 1, 1): '计算机元年'}

6.5字典的构造函数 dict

dict()          创建一个空的字典,等同于{}
dict(iterable)  用可迭代对象创建一个新的字典
dict(**kwargs)  用关键字传参形式创建一个新的字典
示例:
------------------------------------------
d = dict()
d = dict([('name', 'tarena'), ('age', 15)])
d = dict((['name', 'weimingze'], "AB"))
d = dict(name='Tarena', age=15)

6.6字典的操作

1）字典的键索引：   用[] 运算符可以获取字典内'键'对应的'值'
2）语法:  v = 字典[键]
3）示例:
------------------------------------------
d = {'name': '李四', 'age': 30}
print(d['name'], '今年', d['age'], '岁')   # 李四今年30岁

6.7 添加/修改字典的元素

1）语法:  字典[键] = 表达式
2）示例:
------------------------------------------
d = {}
d['name'] = '王五'  #创建新的键'name'同时关联值
d['age'] = 15      # 创建键并绑定15
d['age'] = 16      # 修改原来的键'age',重新绑定为16
------------------------------------------
3）说明:
    键不存在,创建键,并绑定值
    键存在,修改键的绑定关系

6.8 删除字典元素 del语句

1）语法：del 字典[键]
2）示例:
------------------------------------------
d = {1:'一', 'hello': 'world', False:'假值'}
del d['hello']

6.9 字典的 in / not in 运算符

in用来判断一个键是否存在于字典中,如果存在返回 True,否则返回False
not in 的返回结果与in 相反
示例:
------------------------------------------
d = {'name': '小张', 'age': 20}
'name' in d  # True
'age' not in d  # False
'小张' in d   # False  (只判断键,不判断值)
20 not in d  # True

6.10 字典的迭代访问

字典是可迭代对象,字典只能对'键'进行访问
示例:
------------------------------------------
d= {'aaa': 111, 'bbb': 222, 'ccc': 333}
for k in d:
    print(k，end = '')     # 111 222 333

6.11 可以用于字典的函数：

len(x)  返回字典的键值对个数
max(x)  返回字典键的最大值
min(x)  返回字典键的最小值
sum(x)  返回字典所有键的和
any(x)  真值测试,只对键进行测试
all(x)  真值测试,全部键为真值.结果才为True
------------------------------------------
示例:
------------------------------------------
d = {0: '零', 5:'伍', 8:'捌', 3:'叁'}
len(d)  # 4
max(d)  # 8
min(d)  # 0
sum(d)  # 16
any(d)  # True
all(d)  # False

6.12 字典的方法

方法名         说明
D.clear()     清空字典
D.pop(key)    移除键,同时返回此键对应的值
D.copy()      返回字典D的副本(浅拷贝)
D.update(D2)  将字典D2合并到D中,如果键相同,则此键的值取D2的值为为新值
D.get(key, default=None)    返回键key所对应的值,如果没有此键,则返回Default的值
D.keys()      返回可迭代的dict_keys集合对象
D.values()    返回可迭代的dict_value集合对象
D.items()     返回可迭代的dict_item对象
------------------------------------------
示例:
------------------------------------------
d = {1: 'One', 2: "Two"}
d2 = {2: '二', 3: '三'}
d3 = d.copy()   # 复制
d3.pop(1)       # d3 = {2: "Two"}
d.update(d2)    # d = {1: 'One', 2: '二', 3: '三'}
d = {1: 'One', 2: '二', 3: '三'}
for k in d.keys():
print(k)        # 1 2 3
for v in d.values():
print(v)        # 'One' '二' '三'
for t in d.items():
print(t)        # (1, 'One') (2, '二') (3, '三')

6.13 字典推导式
是用可迭代对象生成字典的表达式

1）语法:  {键表达式 : 值表达式 for 变量 in 可迭代对象[if 真值表达式]}
    注: []表示其中的内容可省略
2）示例： 生成一个字典,键为数字 1 ~ 9,值为键的平方
------------------------------------------
d = {x : x ** 2 for x in range(1, 10)}
------------------------------------------
3）字典推导式的嵌套等同于列表推导式的嵌套

6.14 字典 VS 列表

1）都是可变对象
2）索引方式,列表用整数索引,字典用键索引
3）大数据量的情况下，字典的插入,删除,修改的速度会快于列表
3）列表的存储是有序的,字典的存储是无序的

7、集合

7.1 定义

集合石可变的容器
集合内的数据对象都是唯一的（不能重复多次的）
集合是无序的数据结构，集合众的数据没有先后关系
集合内的元素必须是不可变的对象
集合是可迭代对象，可用于for语句中
集合是相当于只有键没有值得字典（键则是集合的数据）

7.2 创建空的集合：

set()

7.3创建非空集合的字面值：

s = {1,2,3}

7.4 集合的构造函数：

set()         创建一个空的集合(不能用{} 来创建空集合)
set(iterable) 用可迭代对象创建一个新的集合
------------------------------------------------
示例：
------------------------------------------------
s=set()
s={2,3,5,7}
s=set("ABC")
s=set("BBCXVB")  # s={'B','C','X','V'}  # 可迭代对象，可去除重复元素
s=set(1:"1")     # s={1}        
s=set(('ABC','123','True'))
s={True,None,'ABC',(1,2,3)}

7.5 集合的运算
交集& 并集| 补集- 对称补集^ 子集< 超集 >

1）& 用于生成两个集合的交集
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s1 & s2  # {2, 3}
2）| 生成两个集合的并集
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s1 | s2  # {1, 2, 3, 4}
3）- 生成两个集合的补集
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s1 - s2  # {1}  # 生成属于s1, 但不属于s2的所元素的集合
4）^ 生成两个集合的对称补集     # a中有b中没有的 and b中有的a中没有的 
    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    s1 ^ s2  # {1, 4}

5） > 判断一个集合是另一个集合的超集
   < 判断一个集合是别一个集合的子集
    s1 = {1, 2, 3}
    s2 = {2, 3}
    s1 > s2  # True
    s2 < s1  # True
6）== != 集合相同/不同
    s1 = {1, 2, 3}
    s2 = {3, 2, 1}
    s1 == s2   # True

7.6 in / not in 运算

in 同列表和字典的in运算符规则相同,如果存在于集合中返回 True,否则返回False
示例:
----------------------------
2 in {1, 2, 3}   # True

7.7 用于集合的函数：

len(x)  返回集合的长度
max(x)  返回集合的最大值元素
min(x)  返回集合的最小值元素
sum(x)  返回集合中所有元素的和
any(x)  真值测试，规则与列表相同
all(x)  真值测试，规则与列表相同

7.8 集合的方法：

t.add('x')               # 添加一项
s.update([10,37,42])     # 在s中添加多项
t.remove('H')            # 使用remove()可以删除一项：
len(s)                   # 返回s 的长度
s.issubset(t)            # 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)          # 测试是否 t 中的每一个元素都在 s 中
s.union(t)               # 返回一个新的 set 包含 s 和 t 中的每一个元素
hash(s)                  # 返回 s 的 hash 值
s.pop()                  # 删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError
s.clear()                # 删除 set “s”中的所有元素

7.9 集合推导式:
是用可迭代对象创建集合的表达式

1）语法:        {表达式 for 变量 in 可迭代对象 [if 真值表达式]}  注： [] 部分代表可省略
2）示例:
------------------------------------------------
numbers = [1,2,3,4,5]
s = {x ** 2 for x in numbers if x % 2 == 1}
print(s）    # 1 9 25

7.10 固定集合 frozenset
固定集合是 不可变 的、无序的、含有唯一元素的集合

1)作用:
    固定集合可以作为字典的键，也可以作为集合的值
    注：集合不能作为字典的键，但是固定集合可以，固定集合中可以包含固定集合

2）固定集合的构造函数 frozenset
    frozenset()  创建一个空的固定集合
    frozenset(iterable) 用可迭代对象创建一个新的固定集合
3）示例:
------------------------------------------------
    fz = frozenset()
    fz = frozenset("ABCAB")
    fz = frozenset([1, 2, 3, 4, 5])

7.11 固定集合的运算：

& 交集
|  并集
- 补集
^ 对称补集
in / not in运算
> >= < <= == !=
(以上运算等同于集合的运算)