Lesson_5

---

【1】元组(牢笼中的的列表)

元组 tuple

我们这里说的元组不是那个赫赫有名的元组零食、元组蛋糕。

能力越大的人都有可能滥用权力，反而导致自身万劫不复。

同样，因为列表过于强大，python的作者发明了它的表亲---元组。

元组和列表的最大区别就是，元组里面的数据是不可动的。

访问和创建一个元组

元组和列表，除了不可变这个特征意外，那就是list用的中括号，tuple用的是小括号

tuple1 = ()

tuple2 = (1,) #只有一个元素的时候一定要在结尾加上一个逗号，不加上逗号就是number

tuple3 = (1,2,3)

print('tuple1:',tuple1,type(tuple1))
print('tuple2:',tuple2,type(tuple2))
print('tuple3:',tuple3,type(tuple3))

#tuple1: () <class 'tuple'>
#tuple2: (1,) <class 'tuple'>
#tuple3: (1, 2, 3) <class 'tuple'>

另类定义：

tuple1 = 1,  #number加上逗号就是tuple，不加就是数字

tuple2 = 1,2,3


print('tuple1:',tuple1,type(tuple1))
print('tuple2:',tuple2,type(tuple2))

#tuple1: (1,) <class 'tuple'>
#tuple2: (1, 2, 3) <class 'tuple'>

我们尝试一下不带逗号会怎么样：

tuple1 = (1)

tuple2 = (1,)

print(tuple1 * 3)
print(tuple2 * 3)

#3
#(1, 1, 1)

访问tuple的索引和list是一样的：

tuple1 = ((1,2,3),4,(5,6,7),[1,2,3])
#二维的元组，可以嵌套多类型的数据

print(tuple1[0][0])
print(tuple1[1])
print(tuple1[3][2])

#1
#4
#3

tuple也是可以切片的：

tuple1 = 1,2,3,4,5,6,7,8,9

print(tuple1[:5])  #从0开始取列表中钱5个元素
print(tuple1[-1])  #查找最后一个元素
print(tuple1[::2]) #隔2个查一次
print(tuple1[::-1]) #返回翻转的结果

#(1, 2, 3, 4, 5)
#9
#(1, 3, 5, 7, 9)
#(9, 8, 7, 6, 5, 4, 3, 2, 1)

tuple的元素是不可变的：

修改：

tuple1 = 1,2,3,4,5,6,7,8,9

tuple1[0] = 0

print(tuple1)

#TypeError: 'tuple' object does not support item assignment

删除：

tuple1 = 1,2,3,4,5,6,7,8,9

del tuple1[-1]

print(tuple1)

#TypeError: 'tuple' object does not support item assignment

更新和删除元组

修改

前面说过了，元组的元素具有不可变性，那么有没有其它办法了？

我们可以通过合并的方式向元组的尾部或者头部插入数据

tuple1 = '成龙','李连杰','李小龙'

name1 = '梁小龙',  

name2 = '元彪','洪金宝'

tuple1 = tuple1 + name1 #通过拼接在重新赋值给 tuple1

tuple1 = name2 + tuple1

print(tuple1)


#('元彪', '洪金宝', '成龙', '李连杰', '李小龙', '梁小龙')

#注意：拼接只能是同类型之间拼接

得到结论，元组要修改就必须要重新赋值。

删除元组

删除元组的元素我们在上面的内容已经尝试过了，是不可实现的。

元组的删除和修改差不多，要删就全删。

tuple1 = '成龙','李连杰','李小龙'

del tuple1

返回指定值得下标

tuple1 = '成龙','李连杰','李小龙'


print(tuple1.index('成龙'))

#0

返回元组的个数

tuple1 = '成龙','李连杰','李小龙'

print(len(tuple1))

#3

返回元组中的最大值和最小值

tuple1 = 1,2,3,4,5,6,7


print(max(tuple1))
print(min(tuple1))

#7
#1

返回数组的和

tuple1 = 1,2,3,4,5,6,7

tuple1 = 1,2,3,4,5,6,7

print(sum(tuple1))


#28

将元组转成列表

tuple1 = 1,2,3,4,5,6,7

print(list(tuple1))

#[1, 2, 3, 4, 5, 6, 7]

将其它类型转成tuple

list1 = [1,2,3,4,5,6,7]

string = '123344'

print(tuple(list1))
print(tuple(string))

#(1, 2, 3, 4, 5, 6, 7)
#('1', '2', '3', '3', '4', '4')

#number 和 bool 类型的值是不可迭代的，所以不能转换

元组的遍历

tuple1 = [1,2,3,4,5,6,7]

for i in tuple1:
    print(i)

【2】string补充

字符串我们在前面的内容里面已经学过不少了，想必大家消化的差不多了，
我们今天再来一波新的用法。

splitlines([keepends]) 多行分割

默认keepends = false的，表示不保留换行符

str40 = '''sunck is a good man!
sunck is a nice man!
sunck is handsome man!
'''
print(str40.splitlines(True))

#['sunck is a good man!\n', 'sunck is a nice man!\n', 'sunck is handsome man!\n']

max()、min()

max()、min(）可以判断字符串大小值

str1 = "abcdefg!"
print(max(str1))
print(min(str1))

#g
#!

<image src='images/timg.jpeg'/>

创建字符映射的转换表

str.maketrans(intab, outtab) 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

str1 = str.maketrans("ac", "65")

print(str1)

#{97: 54, 99: 53}

过滤字符映射

translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。

str.translate(table, deletechars)

table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。

例如：

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)  # 制作翻译表

str = "this is string example....wow!!!"
print(str.translate(trantab))

#th3s 3s str3ng 2x1mpl2....w4w!!!

编码

encode() 方法以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。

encoding -- 要使用的编码，如"UTF-8"。

errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

看个例子：

str1 = "这是一个字符串"
#ignore忽略错误
data2 = str1.encode("utf-8", "ignore")
print(data2)
print(type(data2))

#解码  注意：要与编码时的编码格式一致
str3 = data2.decode("gbk", "ignore")
print(str3)


#b'\xe8\xbf\x99\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
#<class 'bytes'>
#杩欐槸涓涓瀛楃︿覆

字符判断

isalpha()

如果字符串中至少有一个字符且所有的字符都是字母返回True,否则返回False

str1 = "abcde"
print(str1.isalpha())

>>>True

isalnum()

如果字符串中至少有一个字符且所有的字符都是字母或数字返回True,否则返回False

str1 = "1a2b3"
print(str1.isalnum())

>>>True

isspace()

如果字符中只包含空格则返回True,否则返回False

print(" ".isspace())
print("      ".isspace())
print("\t".isspace())
print("\n".isspace())
print("\r".isspace())

【3】字典(dict)

我们在翻开《新华字典》的时候想查一个字的时候，比如“万“，我们不会从‘a’到‘z’开始逐个查找，而是直接从‘w’开始，接着找wan这个发音，最终找个”万“字。

python中的字典类型会把‘wan’看着是 键（key）,”万“字看着是值（value），另外python中的 dict在有些地方称为哈希（hash），有些地方称为 关系数组，也和javascript 的轻量数据交换格式（json）是一样的。

用键-值(key-value)存储，具有极快的查找速度

<font color='red'>注意：字典是映射关系,字典不能被切片</font>

key的特性：

1、字典中的key必须唯一
2、key必须是不可变对象
3、字符串、整数等都是不可变的，可以作为key
4、list是可变的，不能作为key

字典是Python语言中唯一的映射类型。
映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。
字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。
字典类型与序列类型的区别：
1.存取和访问数据的方式不同。
2.序列类型只用数字类型的键（从序列的开始按数值顺序索引）；
3.映射类型可以用其他对象类型作键（如：数字、字符串、元组，一般用字符串作键），和序列类型的键不同，映射类型的键直接或间接地和存储数据值相关联。
4.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。
5.映射类型用键直接“映射”到值。
字典是Python中最强大的数据类型之一。

创建和访问dict

创建dict

字典在创建的时候必须是{'key':'value'}

dict1 = {}
dict2 = {'name':'tom','sex':'male','age':25}
dict3 = dict()
print(dict1,type(dict1))
print(dict2,type(dict2))
print(dict3,type(dict3))

#{} <class 'dict'>
#{'name': 'tom', 'sex': 'male', 'age': 25} <class 'dict'>
#{} <class 'dict'>

访问dict

访问dict必须要指定它的key

dict1 = {'name':'tom','sex':'male','age':25}

print(dict1['name'])

#tom

添加一个新的值

dict1 = {'name':'tom','sex':'male','age':25}
dict1['height'] = '175cm'
print(dict1)

#{'name': 'tom', 'sex': 'male', 'age': 25, 'height': '175cm'}

修改指定的值

dict1 = {'name':'tom','sex':'male','age':25}
dict1['age'] = '30'
print(dict1)

#{'name': 'tom', 'sex': 'male', 'age': '30'}

删除指定的值

dict1 = {'name':'tom','sex':'male','age':25}

dict2 = dict1.copy()

dict3 = dict1.copy()

del dict1['age']        #直接删除

print(dict2.pop('sex')) #弹出一个指定的键，并返回被弹出的值

print(dict3.popitem())  #弹出最后一项，并返回被弹出的值

print(dict1)
print(dict2)
print(dict3)

#male
#('age', 25)
#{'name': 'tom', 'sex': 'male'}
#{'name': 'tom', 'age': 25}
#{'name': 'tom', 'sex': 'male'}

深度拷贝dict

dict1 = {'name':'tom','sex':'male','age':25}

dict2 = dict1.copy()  

dict3 = dict1

dict1.pop('age')

print(id(dict1),dict1)
print(id(dict2),dict2)
print(id(dict3),dict3)

#4303185888 {'name': 'tom', 'sex': 'male'}
#4303185960 {'name': 'tom', 'sex': 'male', 'age': 25}
#4303185888 {'name': 'tom', 'sex': 'male'}

清除dict

dict.clear()

不管是list还是dict，清除都建议使用clear(),为什么了？举个例子

dict1 = {'name':'tom','sex':'male','age':25}

dict2 = dict1

dict1 = {}

print(id(dict1),id(dict2))
print(dict1,dict2)

#4301088808 4301088736
#{} {'name': 'tom', 'sex': 'male', 'age': 25}

上面的例子中 dict1 = {} 并没有把内存中的值给去除， 而是从新定义了一个 空dict，把指针指向了另一个地址.

dict2是浅拷贝dict1的，那么原来的值还在内存中。这样做的弊端就是浪费内存的使用空间。

使用clear()试一下

dict1 = {'name':'tom','sex':'male','age':25}

dict2 = dict1

print(id(dict1),id(dict2))  #这是清理之前的内存地址

dict1.clear()

print(id(dict1),id(dict2))

print(dict1,dict2)


#4301088736 4301088736
##4301088736 4301088736
{} {}

使用clear()以后两个被一起清理了，而且是在原内存空间上做清理的。

所以不论是list、dict都建议使用.clear()

修改dict

dict1 = {'name':'tom','sex':'male','age':25}

dict1['age'] = 26

dict1.update(sex = 'female')

dict1['cname'] = '汤姆'       #指定key可以修改也可以添加

dict1.update(height = '170')  #height并不存在

print(dict1)

#{'name': 'tom', 'sex': 'female', 'age': 26, 'cname': '汤姆', 'height': '170'}

上面的例子我们能看出来.update()和指定key的效果是一样的，如果指定的 键值对 已经存在 则修改，不存在 则添加

<font color='red'>注意：update(key = ‘value’)中key是不带引号的，而value是带引号的，除非它是整数</font>

宽松访问

get()方法提供了更加合适的访问方式。

dict1 = {'name':'tom','sex':'male','age':25}

print(dict1.get('age'))

print(dict1.get('height'))

print(dict1.get('height','not find'))

#25            找到对应的key则返回value
#None          没有找到key返回None
#not find      如果设置第二个参数，找到key返回对应的value，没有找到返回设定的默认值

相同的，可以用 in 和 not in 判断是否在dict里面，但是只能用key作为查找条件

dict1 = {'name':'tom','sex':'male','age':25}

print('name' in dict1)

#True

其它方式创建dict

fromkeys()用于创建一个新的字典，它有两个参数，第一个参数是字典的 键 ，第二个参数是可选的，是传入键的对应值，第二个参数不写的话，值默认是None。

<font color='red'>注意：第一个参数必须是可迭代的序列，在我们python中可迭代的序列中有三种，str，list，tuple。而且它是返回一个新的字典，并不会改变原来的值</font>

dict1 = {}
print(dict1.fromkeys('12','str'))
print(dict1.fromkeys([2,3],(1,2,3)))
print(dict1.fromkeys((5,6)))

#{'1': 'str', '2': 'str'}
#{2: (1, 2, 3), 3: (1, 2, 3)}
#{5: None, 6: None}

上面的例子告诉我们做事不能想当然，在第二个print()中并不会将(1,2,3)拆开，而是将他们当着一个值。

keys(),values(),items()

访问字典的方法还有keys(),values(),items()

keys()是返回字典中的所有键，values()是返回字典中的值，那么items()就是返回字典中的键值对。items()返回的是一个list，每个元素都是tuple。

dict1 = {'name':'tom','sex':'male','age':25}

print(dict1.keys())
print(dict1.values())
print(dict1.items())

#dict_keys(['name', 'sex', 'age'])
#dict_values(['tom', 'male', 25])
#dict_items([('name', 'tom'), ('sex', 'male'), ('age', 25)])

课堂小作业：

list1 = [('name', 'tom'), ('sex', 'male'), ('age', 25)]

我们将list转换成dict，不使用dict()。

list1 = [('name', 'tom'), ('sex', 'male'), ('age', 25)]

dict1 = {}

for each in list1:
    dict1[each[0]] = each[1]
print(dict1)

#{'name': 'tom', 'sex': 'male', 'age': 25}