文章目录
编程规范
行与缩进
python最具特色的就是使用缩进来表示代码块。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
注释
- 单行注释：
# 单行注释
# 这是一条单行注释
- 多行注释：
'''多行注释'''"""多行注释"""
'''
多行注释的第一种方法
多行注释的第一种方法
'''
"""
多行注释的第二种方法
多行注释的第二种方法
"""
多行语句
python通常在一行写完一条语句，如果语句太长，可以分行写，在行末加上\即可：
sum = number1 + \
number2 + \
number3
在{} [] ()里面的多行语句，不需要加\
python也可以在一行显示多条语句，语句之间用;隔开
输入与输出
- 输入：
input("等待用户输入")
- 输出：
# python中默认是换行输出的
print("a")
print("b")
# 想要不换行输出，加上 end="" 就可以
print("a",end=" ")
print("b",end=" ")
空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
导入模块
import xxx
导入某个模块from xxx import aaa
导入某个模块的某个函数from xxx import aaa,bbb,ccc
导入某个模块的多个函数from xxx import *
导入某个模块的所有函数
help函数
调用 python 的 help() 函数可以打印输出一个函数的文档字符串：
>>> help(max)
Help on built-in function max in module builtins:
max(...)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.
函数与方法
值得注意的是python中方法和函数时有区别的：
- 区别一：所处的位置
函数是直接写在文件中而不是class中的，方法只能写在class中。
- 区别二：二者的定义方式不同
函数定义的方式 def关键字 然后接函数名 再是括号 括号里面写形参也可以省略不写形参
方法定义的方式 首先方法是定义在类中的其他他大体和函数定义差不多，方法必须带一个默认参数(相当于this)，静态方法除外。
- 区别三：二者的调用方式不同
函数的调用：函数名(参数1,参数2,…)
方法的调用：对象实例.方法(参数) （这里是指对象方法）
变量
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
name = "bob" # String类型
age = 19 # 整型
salary = 10000.0 # 浮点型
python同样支持连等给多个变量同时赋值：
- 赋同一个值
a = b = c = 1
- 赋不同的值
a, b, c = 1, 2, 3
运算符
算数运算符
一般的运算符
+加 -减 *乘 %取余
python都支持，python中比较特殊的是：
/除 （这个符号在java中给整型用有整除的用法）
>>> print (4/3)
1.3333333333333333
但是java中输出4/3就是1（和python中的//用法类似）
**返回幂次方
>>> print (2 ** 4)
16
//整除
>>> print (10 // 3)
3
// 并不一定总是返回一个整数类型的值，它与分支分母的数据类型有关系：
>>> print (10 // 3.0)
3.0
>>> print (10.0 // 3)
3.0
比较运算符
==比较对象是否相等!=比较两个对象是否不相等>大于<小于>=大于等于<=小于等于
赋值运算符
=赋值+=加法赋值运算符 a+=b 等效于 a = a+b 其他类似-=减法赋值运算符*=乘法赋值运算符/=除法赋值运算符%=取余赋值运算符**=幂赋值运算符//=整除赋值运算符
位运算符
按位运算符是把所有的数字当做二进制来计算的。
-
&-按位与
参与运算的两个值，如果相应位都为1，那么结果值相应位为1，否则为0 -
|-按位或
参与运算的两个值，只要有一个为1，那么结果就为1 -
^-按位异或
当两相应的二进制相异时结果为1 -
~-按位取反
对数据的每个二进制取反 1 相互转换 0
~x类似于-x-1，比如 ~3 = -3-1 = -4 -
<<-左移
运算数的各二进制位全部左移若干位，由<<右边的数指定移动的位数，高位丢弃，低位补0。相当于给原数乘以2的n次幂。比如5<<2 = 5 * （2 ** 2）= 5 *4 =20 -
>>-右移
把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数
逻辑运算符
-
and布尔与 -
or布尔或 -
not布尔非
优先级：not > and > or
在python中，逻辑运算返回的值并不限定于True / False。
python中的任何数据类型都有逻辑值，所以逻辑运算符可以对所有数据进行操作。
| 数据类型 | False | True |
|---|---|---|
| 整型 | 0 | 其他 |
| 浮点型 | 0.0 | 其他 |
| 字符串 | ‘’ | 其他 |
| 字典 | {} | 其他 |
| 元组 | () | 其他 |
| 列表 | [] | 其他 |
| None | None |
- 举例
A and B
case 1：A 是 False ，返回 A（所以python的逻辑与是短路与）。
case 2：A 是 True，返回 B 。
理解：可以这么理解，与的话要两个参数都为真才返回真，那么就会先判断A，A 为假就直接返回假（A），A为真那么结果就取决于B的真假，返回B就可以。
A or B
case 1：A 是 False，返回 B
case 2：A 是 True，返回 A
理解：和and反着来，或的话就要求只要有一个为真就返回真，先判断A ，A 为 真 就直接返回真（A），A 为假那么结果就取决于B，返回B。
not A
case 1：A 是 False，返回 True
case 2：A 是 True，返回 False
理解：这个没什么好说的，取反就可以了
成员运算符
Python还支持一些成员运算符，成员包括字符串，列表和元祖。
in
如果在指定的序列中找到值则返回True，否则返回Falsenot in
如果在指定的序列中没有找到值返回 True，否则返回 False。
身份运算符
身份运算符用于比较两个对象的存储单元是否相同。
is
判断两个标识符是否引用自同一个对象is not
判断两个标识符是不是引用自不同对象
id()函数用来获取对象的内存地址，x is y， 类似id(x) == id(y)；x is not y， 类似id(a) != id(b)
- is 和 == 的区别
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
list = [1,2,3]
list2 = list3 = list
print(list2 is list3) # True
print(list2 == list3) # True
list2 = ['a','b','c']
list3 = ['a','b','c']
print(list2 is list3) # False
print(list2 == list3) # True
运算符的优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND’ |
| ^| | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| and or not | 逻辑运算符 |
基础数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
其中：
- 不可变数据（3 个）：
Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：
List（列表）、Dictionary（字典）、Set（集合）。
使用功能type()函数可以查看变量所指的对象类型此外还可以用isinstance()函数来判断类型，二者的区别是，type()函数不会认为子类是一种父类类型，isinstance()函数会认为子类是一种父类类型。
Number数字数据类型
Python3中支持的数字类型有：int，float，bool，complex
- int 整数类型，长整型，是正或负的整数，不带小数点，可以用十六进制或者八进制表示
- float 浮点型，整数+小数，可以用科学计数法表示，比如1.234e4
- bool 布尔型，0表示False，其余表示True
- complex 复数，实部加虚部构成，可以用a+bj或者complex(a,b)表示，其中a和b都是float
数字类型之间的转换
Python中数据类型的转换非常简单，你只需要将数据类型作为函数名即可。
- int(x) 将x转换为整数，x不能为复数
- float(x) 将x转换为一个浮点数，x不能为复数
- complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
数学函数
使用前导入math模块：import math
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,…) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,…) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| round(x [,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
| sqrt(x) | 返回数字x的平方根。 |
示例：
import math
# 绝对值
print(abs(-10)) # 10
# 向上取整
print(math.ceil(2.1)) # 3
# e的x次幂
print(math.exp(2)) # 7.38905609893065
# 取绝对值
print(math.fabs(-10.3)) # 10.3
# 向下取整
print(math.floor(4.9)) # 4
# 对数计算
print(math.log(100,10)) # 2.0
# lg
print(math.log10(1000)) # 3.0
# 最大值
print(max(1,2,3,4,5)) # 5
# 最小值
print(min(1,2,3,4,5)) # 1
# 指数运算
print(pow(3,3)) # 27
# 求近似值,保留两位小数
print(round(math.pi,2)) # 3.14
# 求近似值,四舍五入取整
print(round(math.pi)) # 3
# 平方根
print(math.sqrt(4)) # 2.0
随机数函数
随机数可以用于数学，游戏，安全等领域，还经常被嵌入到算法中，可以提交算法效率，并提交程序的安全性。
使用时import random
python中包含以下随机数函数：
| 函数 | 描述 |
|---|---|
| choice(seq) | 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
| randrange ([start,] stop [,step]) | 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1 |
| random() | 随机生成下一个实数，它在[0,1)范围内。 |
| seed([x]) | 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| uniform(x, y) | 随机生成下一个实数，它在[x,y]范围内。 |
示例：
import random
# choice 从序列中随机挑选元素
print(random.choice(range(10))) # 随机返回0-9中间的某个数
# start – 指定范围内的开始值，包含在范围内。
# stop – 指定范围内的结束值，不包含在范围内。
# step – 指定递增基数。
print(random.randrange(1,100,2)) # 随机返回1-99中间的奇数
print(random.random()) # 随机生成0-1之间的实数
# 所谓假Random，是指所返回的随机数字其实是一个稳定算法所得出的稳定结果序列，
# 而不是真正意义上的随机序列。 Seed就是这个算法开始计算的第一个值。
# 所以就会出现只要seed是一样的，那么后续所有“随机”结果和顺序也都是完全一致的。
random.seed(10)
print(random.random())
random.seed(10)
print(random.random()) # 生成两个一样的随机数
# 将参数序列随机排列
indexList=[1,2,3,4,5]
random.shuffle(indexList)
print(indexList) # 随机排列1-5
# 在指定的范围内生成实数
print(random.uniform(1,10)) # 随机生成1-10之间的实数
三角函数
| 函数 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x, y) | 返回欧几里德范数 sqrt(xx + yy)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 将角度转换为弧度，x为角度 |
数学常量
- pi 圆周率
- e 自然常数
import math
print(math.pi)
print(math.e)
String字符串类型
使用'或者"来给变量赋值即可创建字符串。
使用\转义特殊字符，使用r可以让\失效。
字符串可以用 + 拼接，也可以用 * 重复 。
python的字符串有两种索引方式，有左往右从0开始，从右往左从-1开始。
python中的字符串是不能改变的，通过索引改变字符串的某个字符是无效的。
python中没有单个字符的概念，单个字符也会被看做字符串。
索引：
截取字符串
[n]表示截取第n+1个字符[n:m]表示截取从第n+1个字符开始，到第m个字符中间的所有字符（包含n+1和m）[n:]表示截取n后面的所有字符[:n]表示截取从第一个字符开始，到第n个字符中间的所有字符
>>> str = "abcdef"
>>> print(str[0]) # 输出第一个字符
a
>>> print(str[-2]) # 输出倒数第二个字符
e
>>> print(str[0:]) # 输出从第一个字符开始后的所有字符
abcdef
>>> print(str[1:5]) # 输出从第二个字符开始，到第五个字符中间的所有字符
bcde
>>> print(str[1:-1]) # 输出从第二个字符开始，到倒数第二个字符中间的所有字符
bcde
>>> print(str * 2) # 输出两次str
abcdefabcdef
>>> print(str + 'ghigk') # 拼接
abcdefghigk
>>>
更新字符串
python中的字符串是不可以改变的，你可以通过截取和拼接来生成另外一个字符串。
比如：
>>> str = "helloWorld"
>>> print (str[:5] + "China")
helloChina
转义字符
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ’ | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
字符串运算符
+拼接*重复输出字符串[]通过索引访问字符[ : ]截取字符串中的一部分，左闭右开in成员运算符，如果字符串中包含给定字符就返回Truenot in成员运算符，如果字符串中不包含给定的字符就返回Truer/R原始字符串%格式字符串
举例：
>>> str = "hello"
>>> print (str[4] + "泡果奶") # 拼接
o泡果奶
>>> print ("h" in str)
True
>>> print ("a" not in str)
True
>>> print (str[0:2] + " is a bro")
he is a bro
>>> print (r"/n")
/n
字符串格式化
python支持格式化字符串的输出，可能会用到非常复杂的表达式，最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
举例：
>>> print ("姓名：%s 年龄：%s 性别：%s" % ('张三',19,'男'))
姓名：张三 年龄：19 性别：男
另一种格式化字符串的方法是使用format()函数，基本语法是用{}和:代替了%
format函数接收的参数不限，并且不要求顺序：
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
这部分内容有些杂，待写。
Python三引号
python三引号支持允许一个字符串跨多行，字符串中可以包含换行符，制表符以及其他特殊字符：
str = """when I was young
I'd like to listen to the radio
when then played
I'd sing along
\t 作者：zzz
"""
print(str)
运行结果：
when I was young
I'd like to listen to the radio
when then played
I'd sing along
作者：zzz
它遵循所见即所得的格式，一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。那么使用这种方式就免去了使用转义字符来确定格式。
字符串中的内置函数
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | capitalize() | 将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding=“utf-8”, errors=“strict”) | Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding=‘UTF-8’,errors=‘strict’) | 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
| 6 | endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| 7 | expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0, end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 | isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| 11 | isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 | isdigit() | 如果字符串只包含数字则返回 True 否则返回 False… |
| 13 | islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 | istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string) | 返回字符串长度 |
| 20 | ljust(width[, fillchar]) | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower() | 转换字符串中所有大写字符为小写. |
| 22 | lstrip() | 截掉字符串左边的空格或指定字符。 |
| 23 | maketrans() | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str) | 返回字符串 str 中最大的字母。 |
| 25 | min(str) | 返回字符串 str 中最小的字母。 |
| 26 | replace(old, new [, max]) | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) | 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) | 类似于 index()，不过是从右边开始. |
| 29 | rjust(width,[, fillchar]) | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip() | 删除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) | num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| 32 | splitlines([keepends]) | 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | strip([chars]) | 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() | 转换字符串中的小写字母为大写 |
| 39 | zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
List列表
List 列表是Python中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。支持字符，数字，字符串甚至嵌套列表。
列表用[ ]标识，是python中最通用的复合数据类型。
列表可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list = ['hello',1000,'a']
访问列表中的值
使用下标索引来访问列表中的值，同样可以使用方括号来截取列表。
列表中值的切割也可以用到变量 [头下标:尾下标]（含头不含尾）就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
此处与String类型相似。
更新列表
不同于字符串类型，列表是可以改变的，使用 变量名[索引] = 值 可以给列表中的元素重新赋值，或者你也可以通过append()方法来给列表添加元素。也可以使用del()函数或者remove()函数删除。
- 重新赋值
list = ['a','b','c']
list[0] = 'x'
list[1] = 'y'
list[2] = 'z'
print(list)
运行结果：
['x', 'y', 'z']
- 添加元素
list = ['a','b','c']
list.append('d')
print(list)
运行结果：
['a', 'b', 'c', 'd']
- 删除元素
list = ['a','b','c']
del list[0]
print(list)
运行结果：
['b','c']
列表脚本操作符
+ 和 * 同样对列表有效。
- 号用于组合列表，* 号用于重复列表。
列表的嵌套
即在列表里面的元素是列表：
chars = ['a','b','c']
nums = [1,2,3]
lists = [chars,nums]
print(lists)
运行结果：
[['a', 'b', 'c'], [1, 2, 3]]
列表函数及方法
Python包含以下函数:
| 函数 | 说明 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元组转换为列表 |
python包含以下方法:
| 序号 | 方法 | 说明 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) | 将对象插入列表 |
| 6 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort( key=None, reverse=False) | 对原列表进行排序 |
| 10 | list.clear() | 清空列表 |
| 11 | list.copy() | 复制列表 |
Tuple元组
远组与列表相似，不同的是元组中的元素不能修改，而且元组使用的是小括号，而列表使用的是方括号。
- 新建一个元组
tup1 = ("a","b","c");
tup2 = (1,2,3);
tup3 = 'A','B','C'; # 不适用括号也可以
tub4 = () # 创建一个空元组
- 当元组中只有一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用：
>>>tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
-
元组和字符串类似，下标索引从0开始，可以访问，截取，组合 。
-
元组的元素值是不可以修改的，只能拼接组合。
-
元组中的元素也是不能删除的，只能一次删除整个元组（使用del）
-
+*同样对元组有效 -
元组内置函数
| 函数 | 描述 |
|---|---|
| len(tuple) | 计算元组中的元素个数 |
| max(tuple) | 返回元组中元素的最大值 |
| min(tuple) | 返回元组元素最小值 |
| tuple(seq) | 将列表转换为元组 |
Dictionary字典
字典是另外一种可变容器模型，而且可以存储任意类型的对象。字典跟java中map很像，每一个元素都由键值对组成，每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ：
d = {key1 : value1 ,key2 : value2}
- 键必须是唯一的，值没有要求
- 值可以是任意数据类型，但是键必须是不可变的数据类型：Number String Tuple
访问字典中的值
把相应的键放在方括号中就可以访问到它对应的值：
dict = {'Name': '张三', 'Age': 17, 'Class': '0601'}
print (dict['Name'])
print (dict['Age'])
更新字典
- 修改
dict = {'Name': '张三', 'Age': 17, 'Class': '0601'}
dict['Age'] = 18
- 新增
dict = {'Name': '张三', 'Age': 17, 'Class': '0601'}
dict['Adress'] = '三里屯'
- 删除
dict = {'Name': '张三', 'Age': 17, 'Class': '0601'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
字典键的特性
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，前一个会被覆盖
- 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
字典内置函数&方法
- 内置函数
| 序号 | 函数及描述 | 实例 |
|---|---|---|
| 1 | len(dict) | 计算字典元素个数，即键的总数。 |
| 2 | str(dict) | 输出字典，以可打印的字符串表示。 |
| 3 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
- 内置方法
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | radiansdict.clear() | 删除字典内所有元素 |
| 2 | radiansdict.copy() | 返回一个字典的浅复制 |
| 3 | radiansdict.fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | radiansdict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
| 5 | key in dict | 如果键在字典dict里返回true，否则返回false |
| 6 | radiansdict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | radiansdict.keys() | 返回一个迭代器，可以使用 list() 来转换为列表 |
| 8 | radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | radiansdict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| 10 | radiansdict.values() | 返回一个迭代器，可以使用 list() 来转换为列表 |
| 11 | pop(key[,default]) | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() | 随机返回并删除字典中的一对键和值(一般删除末尾对)。 |
Set集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
# 或者
set(value)
- 添加元素
set.add( x )
将元素 x 添加到集合 set 中，如果元素已存在，则不进行任何操作。
另外一种添加元素的方法，参数可以是元素/列表/元组/字典set.add( x , y , z ...) - 删除元素
set.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，报错。
还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误：set.discatd(x)
随机删除set.pop()在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。 - 计算集合中元素的个数
len(set) - 清空集合
set.clear() - 判断元素是否存在
x in set - 方法整理：
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 删除集合中的元素，该元素在指定的集合中不存在。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
1186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
