本章包含以下内容：
1.列表
·列表的定义
·列表的创建
·向列表中添加元素
·删除列表中的元素
·获取列表中的元素
·列表的常用操作符
·列表的其他方法
2.元组
·创建和访问一个元组
·更新和删除一个元组
·元组相关的操作符
·内置方法
·解压元组
3.字符串
·字符串的定义
·字符串的切片与拼接
·字符串的常用内置方法
·字符串格式化
4.字典
·可变类型与不可变类型
·字典的定义
·创建和访问字典
·字典的内置方法
5.集合
·集合的创建
·访问集合中的值
·集合的内置方法
·集合的转换
·不可变集合
6·序列
·针对序列的内置函数
day04：
列表:
简单数据类型
·整型<class ‘int’>
·浮点型<class ‘float’>
·布尔型<class ‘bool’>
容器数据类型
·列表<class ‘list’>
·元组<class ‘tuple’>
·字典<class ‘dict’>
·集合<class ‘set’>
·字符串<class ‘str’>
1.列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n]。
关键点是「中括号 []」和「逗号 ,」中括号 把所有元素绑在一起
逗号 将每个元素一一分开。
2.列表的创建
创建一个普通的列表
例：
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x)
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
x = [1.0,1.2,1.3]
print(x,type(x[0]))
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
[2, 3, 4, 5, 6, 7] <class 'list'>
[1.0,1.2,1.3] <class 'float'>
利用range()函数创建列表
例：
x = list(range(10))
print(x,type(x))
for i in range(1,10,2):
print(i,' ',end='') #end表示不换行
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
1 3 5 7 9
[10, 8, 6, 4, 2] <class 'list'>
利用推导式创建列表
x = [0]*5
print(x,type(x))
x = [0 for i in range(5)] #在(0，5)中循环5次得到5个0组成的列表
print(x,type(x))
x = [i for i in range(10)]
print(x,type(x))
x = [i for i in range(10,2)] #使用range()函数时，若加步长，则必须输入起始值，否则不会输出结果
print(x,type(x))
x = [i for i in range(1,10,2)]
print(x,type(x))
x = [i**2 for i in range(1,10,2)] #从range()函数中所得数据的平方
print(x,type(x))
x = [i for i in range(100) if i%2 !=0 and i%3 ==0] #if里的条件可以加小括号
print(x,type(x))
[0, 0, 0, 0, 0] <class 'list'>
[0, 0, 0, 0, 0] <class 'list'>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[1, 9, 25, 49, 81] <class 'list'>
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
x = [[0]*3]*4
print(x,type(x))
x[0][0]=1
print(x[0])
print(x,type(x)) #此出看注意还是不太明白
a = [0] * 3
x = [a] * 4
print(x,type(x))
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[1, 0, 0]
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
创建一个混合列表
mix = ['ltt','ll',[5,2,1]]
print(mix,type(mix),type(mix[0]))
['ltt', 'll', [5, 2, 1]] <class 'list'> <class 'str'>
3.向列表中添加元素
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(666)
print('列表的长度:',len(x),x, type(x))
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 666] <class 'list'>
注意：extend()函数在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
例：
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend([666,'ll'])
print('列表的长度:',len(x),x, type(x))
列表的长度: 7 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 666, 'll'] <class 'list'>
严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj) 在编号 index 位置插入 obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(0,'日期')
print('列表的长度:',len(x),x, type(x))
列表的长度: 6 ['日期', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
4.删除列表中的元素
list.remove(obj) 移除列表中某个值的第一个匹配项
list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del var1[, var2 ……] 删除单个或多个对象。
例：
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)
['Wednesday', 'Thursday', 'Friday']
注：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
5.获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
切片的通用写法是 start : stop : step
情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片。
例:
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) #从索引为3的开始
print(x[-3:]) #从索引为-3开始
['Thursday', 'Friday']
['Wednesday', 'Thursday', 'Friday']
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) #stop为3，但是不取stop对应的索引值
print(week[:-3])
['Monday', 'Tuesday', 'Wednesday']
['Monday', 'Tuesday']
情况 5 - " : "
复制列表中的所有元素（浅拷贝）。
eek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
6.列表的常用操作符
等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
元组
[元组] 定义语法为：(元素1, 元素2, …, 元素n)，其中小括号把所有元素绑在一起；逗号将每个元素一一分开。
元组与列表的区别：
·Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
·元组使用小括号，列表使用方括号。
·元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
t1 = (1,2,3,4,5,6,7,8)
print(t1,type(t1))
t2 = t1[::2] #切片[start:stop:step]
print(t2,type(t2))
(1, 2, 3, 4, 5, 6, 7, 8) <class 'tuple'>
(1, 3, 5, 7) <class 'tuple'>
**注意：**元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
例：
print(8 * (8))
print(8 * (8,))
64
(8, 8, 8, 8, 8, 8, 8, 8)
例子：创建二维元组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
print(x[0])
print(x[1])
print(x[0][0], x[0][1], x[0][2])
print(x[0][0:2]) #[start:stop:step]
((1, 10.31, 'python'), ('data', 11))
(1, 10.31, 'python')
('data', 11)
1 10.31 python
(1, 10.31)
元组相关的操作符
·等号操作符：==
·连接操作符 +
·重复操作符 *
·成员关系操作符 in、not in
·「等号 ==」，只有成员、成员位置都相同时才返回True。
·元组拼接有两种方式，用[加号 +]和[乘号 *]，前者首尾拼接，后者复制拼接。
内置方法
元组大小和内容都不可更改，因此只有 count 和 index 两种方法。
t1 = (123,456,789,123)
print(t1.count(123)) #count()是计算某个元素在元组中出现的次数；
print(t1.index(123,1,4)) #index()是查询某个元素在元组中的索引。
2
3
day05
字符串
字符串的定义：
·Python 中字符串被定义为引号之间的字符集合。
·Python 支持使用成对的 单引号 或 双引号。
Python中常见的转义字符
转义字符 描述
·\ 反斜杠符号
·’ 单引号
·" 双引号
·\n 换行
·\t 横向制表符(TAB)
·\r 回车
字符串的切片与拼接
·类似于元组具有不可修改性
·从 0 开始 (和 Java 一样)
·切片通常写成 start:end 这种形式，包括[start 索引]对应的元素，不包括[end索引]对应的元素。也即只包含头，不包含尾。
·索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
字符串的常用内置方法
·capitalize() 将字符串的第一个字符转换为大写。
例：
str1 = 'li lian'
print(str1.capitalize())
Li lian
·lower() 转换字符串中所有大写字符为小写。
·upper() 转换字符串中的小写字母为大写。
·swapcase() 将字符串中大写转换为小写，小写转换为大写。
例：
str1 = 'LI lian'
print(str1.lower())
print(str1.upper())
print(str1.swapcase())
li lian
LI LIAN
li LIAN
count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
例：
str2 = "DAXIExiaoxie"
print(str2.count('xi'))
2
·endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
·startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
例：
str1 = 'Li lian'
print(str1.endswith('ian'))
print(str1.endswith('li'))
print(str1.startswith('Li'))
print(str1.startswith('li'))
True
False
True
False
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。
注：这两种函数的起始相反。
day06：集合和序列
集合
Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
注意，key为不可变类型，即可哈希的值。
例：
num = {
}
print(type(num))
num = {
1, 2, 3, 4}
print(type(num))
<class 'dict'>
<class 'set'>
集合的创建
·先创建对象再加入元素。且加入元素时，所加入的元素始终在集合的第一位。
·在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。
·直接把一堆元素用花括号括起来{元素1, 元素2, …, 元素n}。
·重复元素在set中会被自动被过滤。此即为集合set的特征。
·使用set(value)工厂函数，把列表或元组转换成集合。
集合的内置方法
·set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
·set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
·set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。
remove与diacard函数的区别：
·set.discard(value)用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
·set.pop() 用于随机移除一个元素。
序列
在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
序列的几种内置函数:
·list(sub) 把一个可迭代对象转换为列表。
·tuple(sub) 把一个可迭代对象转换为元组。
·str(obj) 把obj对象转换为字符串。
·len(s) 返回对象（字符、列表、元组等）长度或元素个数。
·max(sub)返回序列或者参数集合中的最大值。
·min(sub)返回序列或参数集合中的最小值。
zip(iter1 [,iter2 […]])
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
例：
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped) # <zip object at 0x000000C5D89EDD88>
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1)) # [1, 2, 3]
print(list(a2)) # [4, 5, 6]
<zip object at 0x000001F0517E38C8>
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[1, 2, 3]
[4, 5, 6]