Python基础

写在前面

　　　　大人不华，君子务实。

一、进制相关

- 进制基础

　　数据存储在磁盘上或者内存中，都是以0、1形式存在的；即是以 二进制 的形式存在；

　　为了存储和展示，人们陆续扩展了数据的表示形式：八进制 -> 十进制 -> 十六进制...

 二进制：0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000 10001  ...
 八进制：0 1 2  3  4   5   6   7   10   11   12   13   14   15   16   17   20    21     ...
 十进制：0 1 2  3  4   5   6   7   8    9    10   11   12   13   14   15   16    17     ...
十六进制：0 1 2  3  4   5   6   7   8    9    a    b    c    d    e    f    10    11     ...

 - 文件读写相关函数方法

　　虽然硬盘上存储形式都是简单的0和1，但是随着计算机科学的快速普及和发展，兼容了越来越多的语言和文字；所以出现了很多编码形式；

　　然而每一种编码都有自己的对应关系且每个byte由8个bit组成：ASCII码规定每个字符由8个bit表示，不能表示汉字；utf-8规定每个汉字由24个bit表示；

　　更多参见：Python基础-day01

　　所以针对存储在硬盘上的数据，要想正确的识别并展示出来，就必须要知道其存储的编码格式，否则则会出现乱码；

#1 Python中文件读写的小例子：

1 #!/usr/bin/python
 2 # -*- coding:utf-8 -*-
 3 
 4 f1 = open('log','r',encoding='utf-8')
 5 f2 = open('log','rb')
 6 data1 = f1.read()
 7 data2= f2.read()
 8 print(data1)
 9 print(data2)
10 
11 result:
12 D:softworkpython35python.exe D:/soft/work/Python_17/day02/s01.py
13 adada英文——_.
14 b'adadaxe8x8bxb1xe6x96x87xe2x80x94xe2x80x94_.'
15 
16 Process finished with exit code 0


log文件内容：adada英文——_.

二、类和对象初探

- 类/class

类，具有某些属性和行为的抽象结构；

代码中，属性对应了一些变量，行为则对应了一些具体的方法；

- 对象/object

对象，是类的实例，即具有某些属性和行为的实物；

- 面向对象

　　- 封装

　　- 继承

　　- 多态

　　　　- 重载

　　...

> 例如：水果是一个类/class，香蕉则是一个对象/object；

- Python 中的类和对象

比如我们常用的字符串类型：

1 class str(object):{...}
2 ---
3 #!/usr/bin/python
4 # -*- coding:utf-8 -*-
5 
6 string = "Hello"
7 new_str = string.upper()
8 print(new_str)

 string 变量通过 '=' 赋值，成为了一个str类的对象实例，存储在内存中；因为str类具有 'upper()' 方法，所以string对象继承了该方法，可以执行相关操作；

三、基本数据类型常用方法介绍

- 字符串/str

　　- 类型：　　不可变（immutable）

　　下面这个小例子，试图修改字符串，解释器报错；

 1 #!/usr/bin/python
 2 # -*- coding:utf-8 -*-
 3 
 4 string = "Hello"
 5 print(string)
 6 print(string[2])
 7 string[2] = '+'
 8 print(string)
 9 print(string[2])
10 
11 ---
12 D:softworkpython35python.exe D:/soft/work/Python_17/day02/s03.py
13 Hello
14 l
15 Traceback (most recent call last):
16   File "D:/soft/work/Python_17/day02/s03.py", line 9, in <module>
17     string[2] = '+'
18 TypeError: 'str' object does not support item assignment
19 
20 Process finished with exit code 1

 　　- 基础功能

　　　　- 1.capitalize | 首字母大写

1 name = 'alex'
2 v = name.capitalize()
3 print(name)
4 print(v)
5 
6 ---
7 alex
8 Alex

 　　　　- 2.casefold 和 lower | 所有大写变小写，casefold 功能强于 lower

 1 name = 'HeLLo!'
 2 v = name.casefold()
 3 v2 = name.lower()
 4 print(name)
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 HeLLo!
10 hello!
11 hello!
 1 # ß 是德语里的一个大写字符
 2 
 3 name = 'ß'
 4 v = name.casefold()
 5 v2 = name.lower()
 6 print(v)
 7 print(v2)
 8 
 9 ---
10 ss
11 ß

　　　　- 3.center, ljust, rjust | 文本居中，居左，居右，并填充显示，arg1 -> 表示总长度；arg2 -> 表示填充字符；

 1 name = 'standby'
 2 v = name.center(10,'#')
 3 v2 = name.ljust(10,'@')
 4 v3 = name.rjust(10,'+')
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 #standby##
11 standby@@@
12 +++standby

 　　　　- 4.count | 子序列在字符串中出现的次数；arg1 -> 子序列； arg2 -> 匹配查找的起始位置； arg3 -> 匹配查找的结束位置；

 1 desc = "This is www.iqiyi.com."
 2 v = desc.count('i')
 3 v2 = desc.count('is')
 4 v3 = desc.count('is',1,5)
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 5
11 2
12 1

 　　　　- 5.encode | 把字符串转换成 bytes 类型表示； arg1 -> 指定编码；

1 name = '中国'
2 new_name1 = name.encode('utf-8')
3 new_name2 = name.encode('gbk')
4 print(new_name1, type(new_name1), len(new_name1))
5 print(new_name2, type(new_name2), len(new_name2))
6 
7 ---
8 b'xe4xb8xadxe5x9bxbd' <class 'bytes'> 6
9 b'xd6xd0xb9xfa' <class 'bytes'> 4

 　　　　- 6.endswith 和 startswith | 是否以xxx结尾、开头； arg1 -> xxx；arg2 -> 匹配查找的起始位置； arg3 -> 匹配查找的结束位置；

1 hitwh = "Just stick to what you love and believe in."
2 v = hitwh.startswith('Just')
3 v2 = hitwh.startswith('s',5,11)
4 v3 = hitwh.endswith('t',5,12)
5 print(v,v2,v3)
6 
7 ---
8 True True True

 　　　　- 7.expandtabs | 找到制表符 ，进行替换；arg1 -> 指定替换后的长度（包含 ' ' 前面的子序列）；

 1 my = 'haha	Python_17	www.baidu.com
www.standby.pub	xxxx	like'
 2 print(my)
 3 v = my.expandtabs(20)
 4 print(v)
 5 
 6 ---
 7 haha    Python_17    www.baidu.com
 8 www.standby.pub    xxxx    like
 9 haha                Python_17           www.baidu.com
10 www.standby.pub     xxxx                like

 　　　　- 8.find 和 index | 查找子序列索引位置，不存在则返回 '-1'；index查找，不存在的话就报错了；默认是从左向右查找，另外还有 rfind 和 rindex，即从右向左查找；

name = 'alex'
v = name.find('e')
v2 = name.find('o')
print(v)
print(v2)

---
2
-1
1 name = 'alex'
2 v = name.index('o')
3 print(v)
4 
5 ---
6 Traceback (most recent call last):
7   File "D:/soft/work/Python_17/day02/s02.py", line 35, in <module>
8     v = name.index('o')
9 ValueError: substring not found

　　　　- 9.format 和 format_map | 格式化输出的几种形式

 1 # Format output 1
 2 my = "I am %s, age is %s, gender is %s."
 3 print(my % ('standby',22,'male'))
 4 # Format output 2
 5 my = "I am {0}, age is {1}, gender is {2}."
 6 print(my.format('standby',23,'male'))
 7 # Format output 3
 8 my = "I am {name}, age is {age}, gender is {gender}."
 9 print(my.format(name = 'standby',age = 24,gender = 'male'))
10 # Format output 4
11 my = "I am {name}, age is {age}, gender is {gender}."
12 print(my.format_map({'name':'standby','age':25,'gender':'male'}))
13 
14 ---
15 I am standby, age is 22, gender is male.
16 I am standby, age is 23, gender is male.
17 I am standby, age is 24, gender is male.
18 I am standby, age is 25, gender is male.

 　　　　- 10.isdecimal, isdigit, isnumeric | 判断是否是数字；isdecimal < isdigit < isnumeric

 1 num = '123'
 2 num2 = '九十八'
 3 num3 = '⑨'
 4 v1 = num.isdecimal()
 5 v2 = num.isdigit()
 6 v3 = num.isnumeric()
 7 print(v1,v2,v3)
 8 v1 = num2.isdecimal()
 9 v2 = num2.isdigit()
10 v3 = num2.isnumeric()
11 print(v1,v2,v3)
12 v1 = num3.isdecimal()
13 v2 = num3.isdigit()
14 v3 = num3.isnumeric()
15 print(v1,v2,v3)
16 
17 ---
18 True True True
19 False False True
20 False True True

 　　　　- 11.isalpha | 判断字符串是否只有字母组成

 1 string = 'str'
 2 name = 'alex123'
 3 v = name.isalpha()
 4 v2 = string.isalpha()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 False
10 True

 　　　　- 12.isalnum | 判断字符串是否由字母和数字组成

 1 name = 'alex123'
 2 string = 'str赢.'
 3 v = name.isalnum()
 4 v2 = string.isalnum()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 True
10 False

　　　　- 13.isidentifier | 判断是否可以用作标识符、变量名

 1 string1 = '1a'
 2 string2 = 'int'
 3 string3 = 'name'
 4 v = string1.isidentifier()
 5 v2 = string2.isidentifier()
 6 v3 = string3.isidentifier()
 7 print(v)
 8 print(v2)
 9 print(v3)
10 
11 ---
12 False
13 True
14 True

 　　　　- 14.islower 和 isupper | 判断字符串是否全都是大、小写

 1 name = 'aLeX'
 2 v = name.islower()
 3 v2 = name.isupper()
 4 print(v)
 5 print(v2)
 6 print(name.upper())
 7 print(name.lower())
 8 
 9 ---
10 False
11 False
12 ALEX
13 alex

 　　　　- 15.isprintable | 是否包含隐含的 ' ' ' ' 'a'...

 1 desc = 'aaa121212---.'
 2 name = 'alex 	sss'
 3 v = name.isprintable()
 4 v2 = desc.isprintable()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 False
10 True

 　　　　- 16.isspace | 是否全部是空格

 1 name = '    '
 2 name2 = '    .'
 3 v = name.isspace()
 4 v2 = name2.isspace()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 True
10 False

 　　　　- 17.join | 字符串/子序列拼接

 1 str = 'alexall'
 2 list = ['A','L','E','X']
 3 v = '-'.join(str)
 4 v2 = ''.join(list)
 5 v3 = '<-->'.join(list)
 6 print(v)
 7 print(type(v2),v2)
 8 print(type(v3),v3)
 9 
10 ---
11 a-l-e-x-a-l-l
12 <class 'str'> ALEX
13 <class 'str'> A<-->L<-->E<-->X

 　　　　- 18.lower, upper, swapcase | 大小写转换：全部变小写、全部变大写、大小写全部对换 

 1 name = 'AleX'
 2 v = name.lower()
 3 v2 = name.upper()
 4 v3 = name.swapcase()
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 alex
11 ALEX
12 aLEx

 　　　　- 19.strip, rstrip, lstrip | 移除空白，' '，' '，也可以自定义要移除的字符

 1 name2 = '   standby     '
 2 v2 = name2.strip()
 3 v3 = name2.lstrip()
 4 v4 = name2.rstrip()
 5 print(v2)
 6 print(v3)
 7 print(v4)
 8 
 9 ---
10 standby
11 standby     
12    standby
1 name = 'alex'
2 v = name.strip("x")
3 v2 = name.strip("a")
4 print(v)
5 print(v2)
6 
7 ---
8 ale
9 lex

　　　　- 20.maketrans 和 translate | 对应关系 + 翻译

1 m = str.maketrans('hello','12345') # 对应关系
2 name = "---->hello@world<-----"
3 v = name.translate(m)
4 print(v)
5 
6 ---
7 ---->12445@w5r4d<-----

　　　　- 21.partition，rpartition | 分割字符串，并保留自定义的分隔符；arg1 -> 分隔符；则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

1 name = 'standby'
2 v = name.partition('nd')
3 print(type(v),v)
4 v1 = name.split('nd')
5 print(type(v1),v1)
6 
7 ---
8 <class 'tuple'> ('sta', 'nd', 'by')           <-- 元组，并且保留了自定义的分隔符： nd
9 <class 'list'> ['sta', 'by']                  <-- 列表，去掉了自定义的分隔符
1 name = 'standby--nd++'
2 v = name.partition('nd')
3 v2 = name.rpartition('nd')
4 print(type(v),v)
5 print(type(v2),v2)
6 
7 ---
8 <class 'tuple'> ('sta', 'nd', 'by--nd++')
9 <class 'tuple'> ('standby--', 'nd', '++')

　　　　- 22.replace | 替换； arg1 -> 匹配的子序列； arg2 -> 指定替换后的子序列； arg3 -> 替换的个数

 1 content = "巴基斯坦help中国help俄罗斯help中国"
 2 print(content)
 3 v = content.replace('help','Love')
 4 print(v)
 5 v = content.replace('help','Love',2)
 6 print(v)
 7 
 8 ---
 9 巴基斯坦help中国help俄罗斯help中国
10 巴基斯坦Love中国Love俄罗斯Love中国
11 巴基斯坦Love中国Love俄罗斯help中国

　　　　- 23.split, rsplit | 通过指定分隔符 arg1 对字符串进行切片，如果参数 arg2 有指定值，则仅分隔 arg2 个子序列

 1 name = 'standby--nd++And######worldnd@@@.'
 2 v = name.split('nd')
 3 v2 = name.rsplit('nd')
 4 v3 = name.split('nd',2)
 5 v4 = name.rsplit('nd',2)
 6 print(type(v),v)
 7 print(type(v2),v2)
 8 print(type(v3),v3)
 9 print(type(v4),v4)
10 
11 ---
12 <class 'list'> ['sta', 'by--', '++A', '######world', '@@@.']
13 <class 'list'> ['sta', 'by--', '++A', '######world', '@@@.']
14 <class 'list'> ['sta', 'by--', '++And######worldnd@@@.']
15 <class 'list'> ['standby--nd++A', '######world', '@@@.']

　　　　- 24. zfill | 填充0； arg1 -> 指定总长度，包括已有字符串长度；

1 name = "alex"
2 v = name.zfill(10)
3 print(v)
4 
5 ---
6 000000alex

 　　- 扩展补充

　　　　- 切片

 1 desc = 'Hello @_@ world.'
 2 print(desc)
 3 print(desc[0])
 4 print(desc[3:7])
 5 print(desc[0:8:2])
 6 
 7 ---
 8 Hello @_@ world.
 9 H
10 lo @
11 Hlo@

 　　　　- 求长度和 for循环遍历

1 desc = 'Hello @_@ world.'
2 print(len(desc))
3 for i in desc:
4     print(i)
5 for i in range(0, len(desc)):
6     print(desc[i])

- 整数/int

　　- 类型　　不可变（immutable）

 1 >>> num=1
 2 >>> id(num)         <-- 查看num的内存地址
 3 1795490256
 4 >>> num2=1　　　　　　<-- 给num2赋予同样的值：1
 5 >>> id(num2)        <-- num2 和 num 引用的是同一个内存地址，可见 Python3 在内存中为每一个值只保存一份；
 6 1795490256
 7 >>>
 8 >>> num=9            <-- 给num重新赋值：9
 9 >>> id(num)          <-- num 的内存地址已经更改了，所以int值是不可变类型的！
10 1795490512
11 >>> id(num2)
12 1795490256
13 >>>
14 >>> num
15 9
16 >>> num2
17 1
18 >>>

 　　- 基础功能

　　　　- 1.bit_length | 查看某整数用二进制表示时的最小位数； 可以用 'bin()' 函数获得整数的二进制表示形式；

 1 print("十进制".ljust(5),"二进制".ljust(5), "二进制表示的最小位数")
 2 for i in range(1,9):
 3     print(str(i).ljust(10), bin(i).ljust(10), i.bit_length())
 4 
 5 ---
 6 十进制   二进制   二进制表示的最小位数
 7 1          0b1        1
 8 2          0b10       2
 9 3          0b11       2
10 4          0b100      3
11 5          0b101      3
12 6          0b110      3
13 7          0b111      3
14 8          0b1000     4

　　　　- 2.to_bytes | 获取指定整数的字节按照大小端序进行表示

 1 num_list = [254,255,256,257]
 2 for age in num_list:
 3     print("%s  大端序  -->  %s" % (age, age.to_bytes(4,'big')))
 4     print("%s  小端序  -->  %s" % (age, age.to_bytes(4,'little')))
 5 
 6 ---
 7 254  大端序  -->  b'x00x00x00xfe'
 8 254  小端序  -->  b'xfex00x00x00'
 9 255  大端序  -->  b'x00x00x00xff'
10 255  小端序  -->  b'xffx00x00x00'
11 256  大端序  -->  b'x00x00x01x00'
12 256  小端序  -->  b'x00x01x00x00'
13 257  大端序  -->  b'x00x00x01x01'
14 257  小端序  -->  b'x01x01x00x00'

　　　　- 3.from_bytes | 把指定大小端序的bytes对象转换成十进制整数表示

1 num_byte_list = [b'x00x00x00xfe', b'x00x00x00xff', b'x00x00x01x00', b'x00x00x01x01']
2 for by in num_byte_list:
3     print("%s  大端序转换为十进制数  -->  %d" % (by, int.from_bytes(by, 'big')))
4 
5 ---
6 b'x00x00x00xfe'  大端序转换为十进制数  -->  254
7 b'x00x00x00xff'  大端序转换为十进制数  -->  255
8 b'x00x00x01x00'  大端序转换为十进制数  -->  256
9 b'x00x00x01x01'  大端序转换为十进制数  -->  257

- 布尔值/bool

　　- 类型　　不可变（immutable）

　　- 基础功能

　　　　- 1.整数里只有0是 False，其他都是 True

　　　　- 2.字符串里只有 "" 是 False，其他均是 True

　　　　- 3.如果列表为空，即[] 视为 False，其他均是 True

　　- 扩展补充

　　　　- 经常会把 'while True' 这样用作最外层的循环使用；

- 列表/list

　　- 类型　　可变类型

　　-基础功能

　　　　- 1.append | 追加元素到列表

1 user_list = ['alex','eric','jerry','tim','alven']
2 v = user_list.append('beric')
3 print(v)
4 print(user_list)
5 
6 ---
7 None
8 ['alex', 'eric', 'jerry', 'tim', 'alven', 'beric']

　　　　- 2.clear | 清空列表元素

1 user_list = ['alex','eric','jerry','tim','alven']
2 user_list.clear()
3 print(user_list)
4 
5 ---
6 []

　　　　- 3.copy | 拷贝列表(浅拷贝)

1 user_list = ['alex','eric','jerry','tim','alven']
2 v = user_list.copy()
3 print(v)
4 print(user_list)
5 
6 ---
7 ['alex', 'eric', 'jerry', 'tim', 'alven']
8 ['alex', 'eric', 'jerry', 'tim', 'alven']

　　　　- 4.count | 计算列表里某个元素重复的个数

1 user_list = ['alex','eric','jerry','tim','alven','tim']
2 v = user_list.count('tim')
3 print(v)
4 
5 ---
6 2

　　　　- 5.extend | 扩展原列表

1 user_list = ['jerry','tim','alven']
2 user_list.extend(['beric','jakie'])
3 print(user_list)
4 
5 ---
6 ['jerry', 'tim', 'alven', 'beric', 'jakie']

　　　　- 6.index | 查找元素索引/下标值；（没有则报错：ValueError: 'xxx' is not in list）

1 user_list = ['alex','eric','jerry','tim','alven']
2 v = user_list.index('tim')
3 # v = user_list.index('tim1')
4 print(v)
5 
6 ---
7 3

　　　　- 7.insert | 在 arg1 索引处插入 arg2 这个元素

1 user_list = ['alex','eric','jerry','tim','alven']
2 user_list.insert(0,'tom')
3 print(user_list)
4 
5 ---
6 ['tom', 'alex', 'eric', 'jerry', 'tim', 'alven']

　　　　- 8.pop | 删除并且获取元素 （按照索引/下标值进行 pop； 不加参数则默认pop出最后一个元素）

1 user_list = ['alex','eric','jerry','tim']
2 # v = user_list.pop()
3 v = user_list.pop(2)
4 print(v)
5 print(user_list)
6 
7 ---
8 jerry
9 ['alex', 'eric', 'tim']

　　　　- 9.remove | 删除列表中的某个元素，arg1 是列表中的值；

1 user_list = ['alex','eric','tim','alven']
2 user_list.remove('eric')
3 print(user_list)
4 
5 ---
6 ['alex', 'tim', 'alven']

　　　　- 10.reverse | 翻转，将列表逆序

 1 user_list = ['jerry','tim','alven']
 2 print(user_list)
 3 v = user_list.reverse()
 4 print(v)
 5 print(user_list)
 6 
 7 ---
 8 ['jerry', 'tim', 'alven']
 9 None
10 ['alven', 'tim', 'jerry']

　　　　- 11.sort | 排序（sort(self, key=None, reverse=False)）； arg1 暂时没讲； arg2 True则是逆序，不写或者False就是顺序；

 1 num_list = [11,3,8,99,21,4]
 2 print(num_list)
 3 num_list.sort()
 4 print(num_list)
 5 num_list.sort(reverse=True)
 6 print(num_list)
 7 
 8 ---
 9 [11, 3, 8, 99, 21, 4]
10 [3, 4, 8, 11, 21, 99]
11 [99, 21, 11, 8, 4, 3]

　　- 扩展补充

 　　　　- 切片（和字符串切片类似）

1 li =['alex','eric','rain','tim','jerry']
2 print(li[0])
3 print(li[0:3])
4 print(li[0:4:2])
5 
6 ---
7 alex
8 ['alex', 'eric', 'rain']
9 ['alex', 'rain']

　　　　- 删除（结合切片功能实现删除多个元素）

1 li =['alex','eric','rain','tim','jerry']
2 print(li)
3 del li[1:4]
4 print(li)
5 
6 ---
7 ['alex', 'eric', 'rain', 'tim', 'jerry']
8 ['alex', 'jerry']

　　　　- 求长度和 for 循环遍历

1 li =['alex','eric','rain','tim','jerry']
2 print(len(li))
3 for i in li:
4     print(i)
5 for i in range(0, len(li)):
6     print(li[i]) 

- 元组/tuple

　　- 类型　　不可变（immutable）

 1 user_tuple = ('alex','eric','alex',)
 2 print(user_tuple[0])
 3 user_tuple[0] = 'li'
 4 
 5 ---
 6 alex
 7 Traceback (most recent call last):
 8   File "D:/soft/work/Python_17/day02/s03.py", line 27, in <module>
 9     user_tuple[0] = 'li'
10 TypeError: 'tuple' object does not support item assignment

　　- 基础功能

　　　　- 1.count | 获取元素出现的个数

1 user_tuple = ('alex','eric','alex',)
2 v = user_tuple.count('alex')
3 print(v)
4 
5 ---
6 2

　　　　- 2.index | 获取指定元素第一个索引位置

1 user_tuple = ('alex','eric','alex',)
2 v = user_tuple.index('alex')
3 print(v)
4 
5 ---
6 0

　　- 扩展补充

　　　　- 元组赋值最后需要加一个 ','

1 li = ('alex')　　　　　　　　　　<--  由于元组赋值最后没有加 ',' 导致被解释器理解为 str 类型
2 tpl = ('alex',)　　　　　　　　  <--  正确写法 
3 print(type(li),li)
4 print(type(tpl),tpl)
5 
6 ---
7 <class 'str'> alex
8 <class 'tuple'> ('alex',)

　　　　- 长度可以用 len() 获取

　　　　- 循环遍历元组

1 user_tuple = ('alex','eric','alex',)
2 for i in user_tuple:
3     print(i)
4 
5 ---
6 alex
7 eric
8 alex

　　　　- 切片

 1 user_tuple = ('alex','eric','jerry','mark','tim','li',)
 2 print(user_tuple[0:2])
 3 print(user_tuple[0:5:2])
 4 print(user_tuple[-1])
 5 print(user_tuple[-3:-1])
 6 
 7 ---
 8 ('alex', 'eric')
 9 ('alex', 'jerry', 'tim')
10 li
11 ('mark', 'tim')

　　　　- 关于元组里面嵌套列表

 1 user_tuple = ('eric','seven',['谢霆锋','王旭','王强'],'alex',)
 2 print(type(user_tuple), user_tuple, len(user_tuple))
 3 print(user_tuple)
 4 print(type(user_tuple[2]), user_tuple[2])
 5 user_tuple[2][1] = '白百合'
 6 print(user_tuple)
 7 
 8 ---
 9 <class 'tuple'> ('eric', 'seven', ['谢霆锋', '王旭', '王强'], 'alex') 4
10 ('eric', 'seven', ['谢霆锋', '王旭', '王强'], 'alex')
11 <class 'list'> ['谢霆锋', '王旭', '王强']
12 ('eric', 'seven', ['谢霆锋', '白百合', '王强'], 'alex')

> 虽然元组是不可变类型，但是里面如果嵌套了可变类型的对象（列表、字典等），例如本例中的 list对象，则可以用 [user_tuple[2][1] = '白百合'] 类似方法去修改所嵌套对象的内部元素的值；

- 字典/dict

　　- 类型　　可变类型

　　- 基础功能

　　　　- 1.clear | 清空一个字典

1 dic = {'k1':'v1','k2':'v2'}
2 print(dic)
3 dic.clear()
4 print(dic)
5 
6 ---
7 {'k2': 'v2', 'k1': 'v1'}
8 {}

　　　　- 2.copy | 拷贝一个字典（浅拷贝）

1 dic = {'k1':'v1','k2':'v2'}
2 v = dic.copy()
3 print(v)
4 print(dic)
5 
6 ---
7 {'k1': 'v1', 'k2': 'v2'}
8 {'k1': 'v1', 'k2': 'v2'}

　　　　- 3.get | 根据key获取指定的value；不存在则返回 None，不报错；

1 dic = {'k1':'v1','k2':'v2'}
2 v = dic.get('k1')
3 print(v)
4 v2 = dic.get('kxxx')
5 print(v2)
6 
7 ---
8 v1
9 None

　　　　- 4.items | 获取键值对

1 dic = {'k1':'v1','k2':'v2'}
2 for item in dic.items():
3     print(item)
4 
5 ---
6 ('k1', 'v1')　　　　　　<-- 元组对象
7 ('k2', 'v2')

　　　　- 5.keys | 获取字典键值

1 dic = {'k1':'v1','k2':'v2'}
2 for item in dic.keys():
3     print(item)
4 
5 ---
6 k2
7 k1

　　　　- 6.pop | 删除并获取对应的value值； arg1 不存在则报错；

1 dic = {'k1':'v1','k2':'v2'}
2 v = dic.pop('k1')
3 print(v)
4 print(dic)
5 
6 ---
7 v1
8 {'k2': 'v2'}

　　　　- 7.popitem | 随机删除键值对，并获取到删除的键值；

1 dic = {'k1':'v1','k2':'v2','k3':'v3'}
2 v = dic.popitem()
3 print(v)
4 print(dic)
5 
6 ---
7 ('k2', 'v2')　　　　　　　　　　<-- 获取的是元组对象
8 {'k3': 'v3', 'k1': 'v1'}

　　　　- 8.setdefault | 增加一个元素，如果键值存在则不做操作；

1 dic = {'k1':'v1','k2':'v2'}
2 dic.setdefault('k3','v3')
3 print(dic)
4 dic.setdefault('k1','1111111')
5 print(dic)
6 
7 ---
8 {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
9 {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

　　　　- 9.update | 批量增加和修改

1 dic = {'k1':'v1','k2':'v2'}
2 print(dic)
3 dic.update({'k3':'v3','k1':'v24'})
4 print(dic)
5 
6 ---
7 {'k1': 'v1', 'k2': 'v2'}
8 {'k3': 'v3', 'k1': 'v24', 'k2': 'v2'}

　　　　- 10.values | 获取字典值

1 dic = {'k1':'v1','k2':'v2'}
2 for item in dic.values():
3     print(item)
4 
5 ---
6 v2
7 v1

　　　　- 11.fromkeys | 原型：dict.fromkeys(seq[], value)； 用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

1 dic = dict.fromkeys(['k1','k2','k3'],'China')
2 print(dic)
3 dic['k1'] = 'Beijing'
4 print(dic)
5 
6 ---
7 {'k2': 'China', 'k3': 'China', 'k1': 'China'}
8 {'k2': 'China', 'k3': 'China', 'k1': 'Beijing'}

　- 扩展补充

　　　　- 1.默认显示键值

1 dic = {'k1':'v1','k2':'v2'}
2 for item in dic:
3     print(item)
4 
5 ---
6 k1
7 k2

　　　　- 2.字典可以嵌套

　　　　- 3.字典的键值必须是不可变类型（字符串、元组、整数、布尔值等都可以）

 1 dic = {
 2     'k1': 'v1',
 3     'k2': [1,2,3,],
 4     (1,2): 'tuple',
 5     111: 'asdf',
 6     True: 'china',
 7     False: 'Japen',
 8 
 9 }
10 print(dic)
11 
12 ---
13 {'k1': 'v1', (1, 2): 'tuple', 'k2': [1, 2, 3], False: 'Japen', True: 'china', 111: 'asdf'}

　　　　　　- 关于True和1

 1 dic1 = {
 2     1: '1',
 3     True: 'True',
 4     False: 'False',
 5 }
 6 dic2 = {
 7     True: 'True',
 8     1: '1',
 9     False: 'False',
10 }
11 print(dic1)
12 print(dic2)
13 
14 ---
15 {False: 'False', 1: 'True'}
16 {False: 'False', True: '1'}

- 集合

　　- 类型　　可变类型，可以理解为不可重复的列表，但是集合是无序的；

　　- 基础功能

　　　　- 1.add | 增加一个元素到集合

1 s1 = {'eric','tony','王阳明'}
2 print(type(s1),s1)
3 s1.add('袁崇焕')
4 print(type(s1),s1)
5 
6 ---
7 <class 'set'> {'tony', 'eric', '王阳明'}
8 <class 'set'> {'tony', 'eric', '袁崇焕', '王阳明'}

　　　　- 2.difference | s1.difference(s2)  -->  列出s1中存在，s2中不存在的元素；

 1 s1 = {'eric','tony','王阳明'}
 2 s2 = {'eric','孙承宗','王阳明'}
 3 v = s1.difference(s2)
 4 v2 = s2.difference(s1)
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 {'tony'}
10 {'孙承宗'}

　　　　- 3.difference_update | s1.difference_update(s2)  --> s1中存在，s2中不存在，然后对s1清空，把对比出结果的赋值给s1

1 s1 = {'eric','tony','王阳明'}
2 s2 = {'eric','孙承宗','王阳明'}
3 print(s1)
4 s1.difference_update(s2)
5 print(s1)
6 
7 ---
8 {'tony', '王阳明', 'eric'}
9 {'tony'}

　　　　- 4.discard | 移除指定元素

1 s2 = {'eric','孙承宗','王阳明'}
2 s2.discard('eric')
3 print(s2)
4 
5 ---
6 {'王阳明', '孙承宗'}

　　　　- 5.intersection | 求交集

1 s1 = {'eric','tony','王阳明'}
2 s2 = {'eric','孙承宗','王阳明'}
3 v = s1.intersection(s2)
4 print(v)
5 
6 ---
7 {'eric', '王阳明'}

　　　　- 6.union | 求并集

1 s1 = {'eric','tony','王阳明'}
2 s2 = {'eric','孙承宗','王阳明'}
3 v = s1.union(s2)
4 print(v)
5 
6 ---
7 {'孙承宗', 'tony', '王阳明', 'eric'}

　　　　- 7.symmetric_difference | 求差集

1 s1 = {'eric','tony','王阳明'}
2 s2 = {'eric','孙承宗','王阳明'}
3 v = s1.symmetric_difference(s2)
4 print(v)
5 
6 ---
7 {'tony', '孙承宗'}

　　　　- 8.pop | 随机移除一个元素，并获取

1 s2 = {'eric','孙承宗','王阳明'}
2 v = s2.pop()
3 print(s2)
4 print(v)
5 
6 ---
7 {'王阳明', 'eric'}
8 孙承宗

　　　　- 9.remove | 删除指定值

1 s2 = {'eric','孙承宗','王阳明'}
2 s2.remove('eric')
3 print(s2)
4 
5 ---
6 {'王阳明', '孙承宗'}

　　　　- 10.update | 批量增加，如果有则忽略

1 s1 = {'eric','tony','王阳明','tim'}
2 s2 = {'eric','孙承宗','王阳明'}
3 s2.update(s1)
4 print(s2)
5 
6 ---
7 {'孙承宗', 'eric', 'tim', '王阳明', 'tony'}

　- 扩展补充

　　　　- 1.set 不记录元素位置或者插入点（无序）。因此，set不支持 indexing, slicing, 或其它类序列（sequence-like）的操作；

　　　　- 2.可以用 len() 获取集合的长度；

　　　　- 3.可以循环遍历

 1 s2 = {'eric','孙承宗','王阳明','白起','商鞅'}
 2 for i in s2:
 3     print(i)
 4 
 5 ---
 6 商鞅
 7 孙承宗
 8 王阳明
 9 eric
10 白起

　　　　- 4.可以把list对象去重：list2 = list(set(list1))

1 user_list = ['china','japan',(1,2),'china',(1,2),1]
2 print(type(user_list),len(user_list),user_list)
3 v = list(set(user_list))
4 print(type(v),len(v),v)
5 
6 ---
7 <class 'list'> 6 ['china', 'japan', (1, 2), 'china', (1, 2), 1]
8 <class 'list'> 4 [(1, 2), 1, 'china', 'japan']

四、关于循环的补充

- range 和 xrange

　　- range()  | arg1 -> 起始计数； arg2 -> 终点计数； arg3 可选，代表的是步长；

 1 for i in range(0,10,2):
 2     print(i)
 3 for j in range(10,0,-2):
 4     print(j)
 5 
 6 ---
 7 0
 8 2
 9 4
10 6
11 8
12 10
13 8
14 6
15 4
16 2

　　- Python 2.7

　　　　- range(1,10) 会立即在内存中生成10个数字；

　　　　- xrange(1,10) 不会立即生成，只有循环迭代时，才一个一个生成；

　　- Python 3.5

　　　　- 没有 xrange() 这个函数；

　　　　- range(1,10) 等价于 Py2.7中的 xrange(0,10)

　　- 常把 range() 和for循环结合使用，遍历数组或者字符串等。

- enumerate

　　- Python的内置函数，表示枚举、列举的意思

　　- 函数原型：enumerate(self, iterable, start=0)； arg1 必须是可遍历的； arg2 可选，即设置起始的数据下标；

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

 1 li =['alex','tim','jerry']
 2 for i,ele in enumerate(li):
 3     print(i,ele)
 4 for i,ele in enumerate(li,100):
 5     print(i,ele)
 6 
 7 ---
 8 0 alex
 9 1 tim
10 2 jerry
11 100 alex
12 101 tim
13 102 jerry

五、练习

要求：

 1 """
 2 # 1. 练习题两个试卷：readme
 3 # 2. 购物系统
 4     - 个人账户,文件： user,pwd,3,余额
 5     - 商品，文件
 6     - 查看商品分页显示：
 7         li = [
 8             {...}
 9             {...}
10             {...}
11             {...}
12             {...}
13             {...}
14             {...}
15         ]
16         p = int(input('请输入页码：'))
17         start = (p -1) * 10
18         end = p * 10
19         v1 = li[start:end]
20         for i v1:
21             print(i)
22     - 个人购物记录，文件
23         查看：娃娃
24     if "al" in "alex":
25         pass
26 """

代码实现：

  1 #!/usr/bin/python
  2 # -*- coding:utf-8 -*-
  3 
  4 import getpass
  5 import time
  6 
  7 WARNING = "You have attempt 3 times which all wrong, so we have to lock your account to keep the security.

  8 You can contact the admin: admin@standby.pub"
  9 GOODS_FILE = "D:softworkPython_17day02goods_info.txt"
 10 USERS_FILE = "D:softworkPython_17day02\user_info.txt"
 11 RECORD_FILE = "D:softworkPython_17day02\record.txt"
 12 OPTIONS = "Type 1 to buy, Type 2 to select your record; 9 to exit... >>>"
 13 
 14 # f.readlines()   --> []
 15 # f.open('file',mode='a',encoding='utf-8')
 16 # user_info = "alex|123|0|900
eric|124|0|800
rain|125|0|666
tim|123|0|1000"
 17 # with open('user_info.txt',mode='w',encoding='utf-8') as f:
 18 #     f.write(user_info)
 19 
 20 # 购物主函数
 21 def do_shopping(user_name):
 22     goods_list = []
 23     buy_array = {}
 24     with open(GOODS_FILE,mode='r',encoding='utf-8') as f:
 25         goods_info = f.readlines()
 26         for line in goods_info:
 27             goods_dict = {
 28                 'name':line.split('|')[0],
 29                 'price':line.split('|')[1],
 30             }
 31             goods_list.append(goods_dict)
 32     while True:
 33         page_num = input("
Input page num >>> ")
 34         if page_num.isdigit():
 35             num = int(page_num)
 36             if 0 == len(goods_info)%3:
 37                 # // 整除     / 带余数
 38                 pages_num = len(goods_info)//3
 39             else:
 40                 pages_num = len(goods_info)//3 + 1
 41             if num >= 1 and pages_num >= num:
 42                 # 1 -> 0-2; 2 -> 3-5; 3 -> 6-8;...
 43                 start_num = num*3-3
 44                 end_num = num*3
 45                 tmp_list = goods_info[start_num:end_num]
 46                 for i,ele in enumerate(tmp_list,1):
 47                     line = '	'.join(tmp_list[i-1].split('|')).expandtabs(20)
 48                     print("{}	{}".format(i,line),end='')
 49                 while True:
 50                     toBuy = input("
Buy something? y/Y to buy, n/N scan continue >>> ")
 51                     if toBuy.isalpha():
 52                         if 'Y' == toBuy.upper():
 53                             goods_num = input("Input the goods number: ")
 54                             if goods_num.isdigit():
 55                                 if int(goods_num) > 0 and int(goods_num) <4:
 56                                     count = input("How many do you want?		")
 57                                     if count.isdigit():
 58                                         index = ((num-1)*3 + int(goods_num)) - 1
 59                                         buy_array[index] = count
 60                         elif 'N' == toBuy.upper():
 61                             break
 62                         else:
 63                             print("Invalid input.")
 64                     else:
 65                         print("Invalid input.")
 66             else:
 67                 print("{} pages only.".format(pages_num))
 68         elif 'Q' == page_num.upper():
 69             print("Bye...")
 70             break
 71         else:
 72             print("Invalid input.")
 73     print("++++++++++++++++++++++++++++++++++++")
 74     print("You have choosen goods below: ")
 75     print("++++++++++++++++++++++++++++++++++++")
 76     sum = 0
 77     buy_array_tmp = {}
 78     for key,value in buy_array.items():
 79         key_num = int(key)
 80         good_name = goods_list[key_num]['name']
 81         buy_array_tmp[good_name] = value
 82         cost = int(goods_list[key_num]['price'])
 83         costs = cost * int(value)
 84         print(goods_list[key_num]['name'] + "	" + "*" + "	" + value)
 85         sum += costs
 86     print("++++++++++++++++++++++++++++++++++++")
 87     print("++++++++++++++++++++++++++++++++++++")
 88     confirm = input("Are you sure to buy them(y/n)?		")
 89     for i in range(0,len(user_list)):
 90         if user_name == user_list[i]['name']:
 91             money = user_list[i]['money']
 92             user_id = i
 93     if "y" == confirm:
 94         if money < sum:
 95             print("Sorry, your credit is running low...")
 96         else:
 97             do_record(user_name,buy_array_tmp)
 98             user_list[user_id]['money'] = money - sum
 99             print("The payment has been successfully completed and you have %d$ left." % (money - sum))
100     else:
101         print("Bye...")
102         exit(0)
103 
104 # 把当前用户购物记录追加到文件中
105 def do_record(username, buy_array_tmp):
106     line = "
"
107     for goods_name,count in buy_array_tmp.items():
108         line = line + username + "|" + goods_name + "|" + count + "|" + 
109           time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
110     with open(RECORD_FILE,mode='a',encoding='utf-8') as f:
111         f.write(line)
112 
113 # 读取用户信息
114 def get_user_list():
115     user_list = []
116     with open(USERS_FILE,mode='r',encoding='utf-8') as f:
117         data = f.read()
118         user_info = data.split('
')
119         for user in user_info:
120             user_dict = {'name': user.split('|')[0], 'pwd': user.split('|')[1],
121              'times': int(user.split('|')[2]), 'money':int(user.split('|')[3])}
122             user_list.append(user_dict)
123     return user_list
124 
125 # 查找购物记录
126 def do_select_record(user_name):
127     while True:
128         key = input("Input keyword, q/Q to exit >>> ")
129         if 'Q' != key.upper():
130             with open(RECORD_FILE,mode='r',encoding='utf-8') as f:
131                 record_list = f.readlines()
132                 flag = -1
133                 for record in record_list:
134                     if user_name in record and key in record:
135                         print(record)
136                         flag = 0
137                 if -1 == flag:
138                     print("No record found...")
139         else:
140             break
141 
142 # 执行操作前的判断
143 def do_something(user_name):
144     options = input(OPTIONS)
145     if options.isdigit():
146         if 1 == int(options):
147             do_shopping(user_name)
148         elif 2 == int(options):
149             do_select_record(user_name)
150         elif 9 == int(options):
151             print("Bye...")
152             exit(0)
153         else:
154             print("Invalid input.")
155             do_something(user_name)
156     else:
157         print("Input not number, type again...")
158         do_something(user_name)
159 
160 # 用户登录验证
161 def login():
162     count = 0
163     while count < 3:
164         name = input("Please input your name: ")
165         flag = -1
166         for item in user_list:
167             if item['name'] == name:
168                 if item['times'] >= 3:
169                     print(WARNING)
170                     exit(0)
171                 else:
172                     count = 0
173                     flag = 0
174                     pwd = getpass.getpass("Please input your password: ")
175                     if item['pwd'] == pwd:
176                         print("Welcome %s." % name)
177                         item['times'] = 0
178                         count = 3
179                         do_something(name)
180                     else:
181                         if 0 == 2-item['times']:
182                             pass
183                         else:
184                             print("Wrong password, you have %s times to retry." % (2-item['times']))
185                         item['times'] += 1
186                     if item['times'] >= 3:
187                         print(WARNING)
188                         count = 3
189                         break
190         if -1 == flag:
191             print("Invalid account, please check your user name...")
192         count += 1
193 
194 # 程序入口
195 user_list = get_user_list()
196 login()
197 
198 # 程序执行结束，格式化用户信息并写回文件
199 result = ""
200 for item in user_list:
201     user_info_str = item['name'] + "|" + item['pwd'] + "|" + str(item['times']) + "|" + str(item['money'])
202     result = result + user_info_str + "
"
203 f2 = open(USERS_FILE,'w')
204 f2.write(result.strip())
205 f2.close()

 涉及到的文件：

 1 user_info.txt:
 2 ---
 3 alex|123|0|90000
 4 eric|124|3|800
 5 rain|125|0|23
 6 tim|123|0|9619
 7 ---
 8 
 9 goods_info.txt
10 ---
11 Linux v1|129
12 Solaris beta|322
13 Free BSD|666
14 AWK cookbook|79
15 GO lang|88
16 Python lang|57
17 CentOS 6.6|333
18 CentOS 5.9|103
19 Unix-like 9|999
20 艽野尘梦|59
21 ---
22 
23 record.txt
24 ---
25 alex|Linux v1|1|2017-05-15 23:37:53
26 alex|GO lang|1|2017-05-15 23:37:53
27 alex|艽野尘梦|3|2017-05-15 23:37:53
28 tim|CentOS 6.6|3|2017-05-15 23:42:26
29 tim|艽野尘梦|1|2017-05-15 23:42:26
30 tim|AWK cookbook|2|2017-05-15 23:42:26
31 tim|艽野尘梦|1|2017-05-15 23:48:52
32 rain|Free BSD|1|2017-05-15 23:50:58
33 rain|Solaris beta|2|2017-05-15 23:52:39
34 tim|Solaris beta|1|2017-05-15 23:53:23
35 ---
作者：Standby — 一生热爱名山大川、草原沙漠，还有妹子
出处：http://www.cnblogs.com/standby/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/standby/p/6819815.html