Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
-
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
-
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
-
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
-
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
一、python语法
1.1、行和缩进
学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
如果省略缩进，Python 会出错
if True:
print ("True")
else:
print ("False")1.2、多行语句
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：
total = item_one + \
item_two + \
item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
1.3、引号
Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""1.4、注释
python中单行注释采用 # 开头。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py
# 第一个注释
print ("Hello, Python!") # 第二个注释1.5、中文编码
Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了
注意：# coding=utf-8 的 = 号两边不要空格。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print( "你好，世界" )二、python变量及类型
变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
2.1、变量赋值
2.1.1、单变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print counter
print miles
print name2.1.2、多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。
2.2、 数据类型
变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。
在这些类别中，Python 默认拥有以下内置数据类型:
| 文本类型: | str |
| 数值类型: | int, float, complex |
| 序列类型: | list, tuple, range |
| 映射类型: | dict |
| 集合类型: | set, frozenset |
| 布尔类型: | bool |
| 二进制类型: | bytes, bytearray, memoryview |
2.3、字符串
2.3.1、字符串字面量
python 中的字符串字面量由单引号或双引号括起。
'hello' 等同于 "hello".
您可以使用 print() 函数显示字符串字面量:
print("Hello")
print('Hello')2.3.2、多行字符串
您可以使用三个引号（单引号或双引号）将多行字符串赋值给变量:
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)a = '''Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.'''
print(a)2.3.3 字符串索引
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
比如:
>>> s = 'abcdef' >>> s[1:5] 'bcde'
当使用以冒号分隔的字符串，python 返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。
上面的结果包含了 s[1] 的值 b，而取到的最大范围不包括尾下标，就是 s[5] 的值 f。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = 'Hello World!'
print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第六个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
输出：
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
2.3.4、字符串长度
如需获取字符串的长度，请使用 len() 函数。
a = "Hello, World!"
print(len(a))2.3.5、字符串内建函数
| 方法 | 描述 |
|---|---|
| 把字符串的第一个字符大写 | |
| 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 | |
| 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
| 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace' | |
| 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' | |
| 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
| 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 | |
| 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 | |
| 格式化字符串 | |
| 跟find()方法一样，只不过如果str不在 string中会报一个异常. | |
| 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False | |
| 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False | |
| 如果 string 只包含十进制数字则返回 True 否则返回 False. | |
| 如果 string 只包含数字则返回 True 否则返回 False. | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | |
| 如果 string 中只包含数字字符，则返回 True，否则返回 False | |
| 如果 string 中只包含空格，则返回 True，否则返回 False. | |
| 如果 string 是标题化的(见 title())则返回 True，否则返回 False | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | |
| 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | |
| 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 | |
| 转换 string 中所有大写字符为小写. | |
| 截掉 string 左边的空格 | |
| maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | |
| 返回字符串 str 中最大的字母。 | |
| 返回字符串 str 中最小的字母。 | |
| 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. | |
| 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. | |
| 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。 | |
| 类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。 | |
| 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 | |
| 类似于 partition()函数,不过是从右边开始查找 | |
| 删除 string 字符串末尾的空格. | |
| 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串 | |
| 按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | |
| 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. | |
| 在 string 上执行 lstrip()和 rstrip() | |
| 翻转 string 中的大小写 | |
| 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | |
| 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 | |
| 转换 string 中的小写字母为大写 | |
| 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
2.3.6、字符串格式化
python 字符串格式化符号:
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %F 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
#!/usr/bin/python
print "My name is %s and weight is %d kg!" % ('Zara', 21)
以上实例输出结果：
My name is Zara and weight is 21 kg!
2.3.7、字符串运算符
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | >>>a + b 'HelloPython' |
| * | 重复输出字符串 | >>>a * 2 'HelloHello' |
| [] | 通过索引获取字符串中字符 | >>>a[1] 'e' |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] 'ell' |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>"H" in a True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >>>"M" not in a True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | >>>print r'\n' \n >>> print R'\n' \n |
| % | 格式字符串 | 请看下一章节 |
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = "Hello"
b = "Python"
print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]
if( "H" in a) :
print "H 在变量 a 中"
else :
print "H 不在变量 a 中"
if( "M" not in a) :
print "M 不在变量 a 中"
else :
print "M 在变量 a 中"
print r'\n'
print R'\n'2.3.8、转义字符
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 |
| \xyy | 十六进制数，以 \x 开头，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
2.3.9、字符串连接
我们可以对字符串进行截取并与其他字符串进行连接，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
var1 = 'Hello World!'
print "输出 :- ", var1[:6] + 'Runoob!'2.3.10、字符串格式化（str.format()）
单个值
format() 方法允许您格式化字符串的选定部分。
有时文本的一部分是你无法控制的，也许它们来自数据库或用户输入?
要控制此类值，请在文本中添加占位符（花括号 {}），然后通过 format() 方法运行值:
price = 49
txt = "The price is {} dollars"
print(txt.format(price))多个值
如需使用更多值，只需向 format() 方法添加更多值:
print(txt.format(price, itemno, count))quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))
索引号
您可以使用索引号（花括号 {0} 内的数字）来确保将值放在正确的占位符中:
quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))此外，如果要多次引用相同的值，请使用索引号:
age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))命名索引
您还可以通过在花括号 {carname} 中输入名称来使用命名索引，但是在传递参数值 txt.format(carname = "Ford") 时，必须使用名称:
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Ford", model = "Mustang"))2.4、Number(数字)
2.4.1、数值类型
Python 支持四种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
- 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
- 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
| int | long | float | complex |
|---|---|---|---|
| 10 | 51924361L | 0.0 | 3.14j |
| 100 | -0x19323L | 15.20 | 45.j |
| -786 | 0122L | -21.9 | 9.322e-36j |
| 080 | 0xDEFABCECBDAECBFBAEl | 32.3+e18 | .876j |
| -0490 | 535633629843L | -90. | -.6545+0J |
| -0x260 | -052318172735L | -32.54e100 | 3e+26J |
| 0x69 | -4721885298529L | 70.2-E12 | 4.53e-7j |
- 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
- Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
2.4.2、Number 类型转换
int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串 2.4.3、 数学函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 |
| 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的平方根 |
2.4.4、随机数函数
| 函数 | 描述 |
|---|---|
| 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]范围内。 |
2.4.5、三角函数
| 函数 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x, y) | 返回欧几里德范数 sqrt(x*x + y*y)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 将角度转换为弧度 |
2.4.6、数学常量
| 常量 | 描述 |
|---|---|
| pi | 数学常量 pi（圆周率，一般以π来表示） |
| e | 数学常量 e，e即自然常数（自然常数）。 |
2.5、列表(List)
Python 编程语言中有四种集合数据类型:
- 列表（List） 是一种有序和可更改的集合。允许重复的成员。
- 元组（Tuple） 是一种有序且不可更改的集合。允许重复的成员。
- 集合（Set） 是一个无序和无索引的集合。没有重复的成员。
- 词典（Dictionary） 是一个无序，可变和有索引的集合。没有重复的成员。
2.5.1 列表的索引
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
2.5.2、更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
print list2.5.3、删除列表元素
可以使用 del 语句来删除列表的元素，如下实例：
#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000]
print list1
del list1[2]
print "After deleting value at index 2 : "
print list12.5.4、表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
2.5.5、列表截取
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 读取列表中第三个元素 |
| L[-2] | 'Runoob' | 读取列表中倒数第二个元素 |
| L[1:] | ['Runoob', 'Taobao'] | 从第二个元素开始截取列表 |
2.5.6、列表函数&方法
Python包含以下函数:
| 序号 | 函数 |
|---|---|
| 1 | cmp(list1, list2) 比较两个列表的元素 |
| 2 | len(list) 列表元素个数 |
| 3 | max(list) 返回列表元素最大值 |
| 4 | min(list) 返回列表元素最小值 |
| 5 | 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(cmp=None, key=None, reverse=False) 对原列表进行排序 |
2.6、元组
2.6.1、元祖和列表区别
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
2.6.2、修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
(12, 34.56, 'abc', 'xyz')
2.6.3、删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python
tup = ('physics', 'chemistry', 1997, 2000)
print tup
del tup
print "After deleting tup : "
print tup
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup
NameError: name 'tup' is not defined
2.6.4、元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print x, | 1 2 3 | 迭代 |
2.6.5、 元组索引，截取
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'SPAM!' | 读取第三个元素 |
| L[-2] | 'Spam' | 反向读取，读取倒数第二个元素 |
| L[1:] | ('Spam', 'SPAM!') | 截取元素 |
2.6.6、无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
#!/usr/bin/python
print 'abc', -4.24e93, 18+6.6j, 'xyz'
x, y = 1, 2
print "Value of x , y : ", x,y
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2
2.6.7、元组内置函数
Python元组包含了以下内置函数
| 序号 | 方法及描述 |
|---|---|
| 1 | cmp(tuple1, tuple2) 比较两个元组元素。 |
| 2 | len(tuple) 计算元组元素个数。 |
| 3 | max(tuple) 返回元组中元素最大值。 |
| 4 | min(tuple) 返回元组中元素最小值。 |
| 5 | tuple(seq) 将列表转换为元组。 |
2.7、字典(Dictionary)
2.7.1、定义
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
>>> tinydict = {'a': 1, 'b': 2, 'b': '3'}
>>> tinydict['b']
'3'
>>> tinydict
{'a': 1, 'b': '3'}值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
2.7.2、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']
tinydict['Age']: 8
tinydict['School']: RUNOOB
2.7.3、删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键是'Name'的条目
tinydict.clear() # 清空字典所有条目
del tinydict # 删除字典
print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']
tinydict['Age']:
Traceback (most recent call last):
File "test.py", line 10, in <module>
print "tinydict['Age']: ", tinydict['Age']
NameError: name 'tinydict' is not defined2.7.4、字典键的特性
字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': 'Manni'}
print "tinydict['Name']: ", tinydict['Name']
tinydict['Name']: Manni
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
#!/usr/bin/python
tinydict = {['Name']: 'Zara', 'Age': 7}
print "tinydict['Name']: ", tinydict['Name']
Traceback (most recent call last):
File "test.py", line 3, in <module>
tinydict = {['Name']: 'Zara', 'Age': 7}
TypeError: unhashable type: 'list'
2.7.5、字典内置函数&方法
Python字典包含了以下内置函数：
| 序号 | 函数及描述 |
|---|---|
| 1 | cmp(dict1, dict2) 比较两个字典元素。 |
| 2 | len(dict) 计算字典元素个数，即键的总数。 |
| 3 | str(dict) 输出字典可打印的字符串表示。 |
| 4 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear() 删除字典内所有元素 |
| 2 | dict.copy() 返回一个字典的浅复制 |
| 3 | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.has_key(key) 如果键在字典dict里返回true，否则返回false。Python3 不支持。 |
| 6 | dict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | dict.keys() 以列表返回一个字典所有的键 |
| 8 | dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | dict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | dict.values() 以列表返回字典中的所有值 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 返回并删除字典中的最后一对键和值。 |
2.8、布尔值
在编程中，您通常需要知道表达式是 True 或 False。
您可以计算 Python 中的任何表达式，并获得两个答案之一，即True 或 False。
比较两个值时，将对表达式求值，Python 返回布尔值答案:
print(10 > 9)
print(10 == 9)
print(10 < 9)评估值和变量
bool() 函数可让您评估任何值，并为您返回 True 或 False
大多数值都为 True
如果有某种内容，则几乎所有值都将评估为 True。
除空字符串外，任何字符串均为 True。
除 0 外，任何数字均为 True。
除空列表外，任何列表、元组、集合和字典均为 True。
2.9、类型转换
有时您可能需要为变量指定类型。这可以通过类型转换来完成。 Python 是一门面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。
因此，使用构造函数完成在 python 中的转换:
- int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
- float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
- str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
x = int(1) # x 将是 1
x = float(1) # x 将是 1.0
y = str(2) # y 将是 '2'2.10、python运算符
运算符用于对变量和值执行操作。
Python 在以下组中划分运算符:
- 算术运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- 身份运算符
- 成员运算符
- 位运算符
2.10.1、算术运算符
算术运算符与数值一起使用来执行常见的数学运算:
| 运算符 | 名称 | 实例 |
|---|---|---|
| + | 加法 | x + y |
| - | 减法 | x - y |
| * | 乘法 | x * y |
| / | 除法 | x / y |
| % | 取模 | x % y |
| ** | 幂 | x ** y |
| // | 地板除（取整除） | x // y |
2.10.2、 赋值运算符
赋值运算符用于为变量赋值:
| 运算符 | 实例 | 等同于 |
|---|---|---|
| = | x = 5 | x = 5 |
| += | x += 3 | x = x + 3 |
| -= | x -= 3 | x = x - 3 |
| *= | x *= 3 | x = x * 3 |
| /= | x /= 3 | x = x / 3 |
| %= | x %= 3 | x = x % 3 |
| //= | x //= 3 | x = x // 3 |
| **= | x **= 3 | x = x ** 3 |
| &= | x &= 3 | x = x & 3 |
| |= | x |= 3 | x = x | 3 |
| ^= | x ^= 3 | x = x ^ 3 |
| >>= | x >>= 3 | x = x >> 3 |
| <<= | x <<= 3 | x = x << 3 |
2.10.3、比较运算符
比较运算符用于比较两个值:
| 运算符 | 名称 | 实例 |
|---|---|---|
| == | 等于 | x == y |
| != | 不等于 | x != y |
| > | 大于 | x > y |
| < | 小于 | x < y |
| >= | 大于或等于 | x >= y |
| <= | 小于或等于 | x <= y |
2.10.4、 逻辑运算符
逻辑运算符用于组合条件语句:
| 运算符 | 描述 | 实例 |
|---|---|---|
| and | 如果两个语句都为真，则返回 True。 | x < 5 and x < 10 |
| or | 如果其中一个语句为真，则返回 True。 | x < 5 or x < 4 |
| not | 反转结果，如果结果为 true，则返回 False | not(x < 5 and x < 10) |
2.10.5、 身份运算符
身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置:
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | 如果两个变量是同一个对象，则返回 true。 | x is y |
| is not | 如果两个变量不是同一个对象，则返回 true。 | x is not y |
2.10.6、 成员运算符
成员资格运算符用于测试序列是否在对象中出现:
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果对象中存在具有指定值的序列，则返回 True。 | x in y |
| not in | 如果对象中不存在具有指定值的序列，则返回 True。 | x not in y |
2.10.7、 位运算符
位运算符用于比较（二进制）数字:
| 运算符 | 名称 | 描述 |
|---|---|---|
| & | AND | 如果两个位均为 1，则将每个位设为 1。 |
| | | OR | 如果两位中的一位为 1，则将每个位设为 1。 |
| ^ | XOR | 如果两个位中只有一位为 1，则将每个位设为 1。 |
| ~ | NOT | 反转所有位。 |
| << | Zero fill left shift | 通过从右侧推入零来向左移动，推掉最左边的位。 |
| >> | Signed right shift | 通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。 |
三、python控制语句
3.1、条件语句
Python 支持来自数学的常用逻辑条件:
- 等于:a == b
- 不等于:a != b
- 小于:a < b
- 小于等于:a <= b
- 大于:a > b
- 大于等于:a >= b
3.1.1 单条件
Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。
Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件：
执行语句……
else：
执行语句……
其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例1：if 基本用法
flag = False
name = 'luren'
if name == 'python': # 判断变量是否为 python
flag = True # 条件成立时设置标志为真
print 'welcome boss' # 并输出欢迎信息
else:
print name # 条件不成立时输出变量名称if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
3.1.2 多条件
当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例2：elif用法
num = 5
if num == 3: # 判断num的值
print 'boss'
elif num == 2:
print 'user'
elif num == 1:
print 'worker'
elif num < 0: # 值小于零时输出
print 'error'
else:
print 'roadman' # 条件均不成立时输出3.2 、While 循环语句
3.2.1、定义
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
while 判断条件(condition)：
执行语句(statements)……
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
当判断条件假 false 时，循环结束。
执行流程图如下：
#!/usr/bin/python
count = 0
while (count < 9):
print 'The count is:', count
count = count + 1
print "Good bye!"3.2.2、无限循环
如果条件判断语句永远为 true，循环将会无限的执行下去，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
var = 1
while var == 1 : # 该条件永远为true，循环将无限执行下去
num = raw_input("Enter a number :")
print "You entered: ", num
print "Good bye!"3.2.3、循环使用 else 语句
在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
#!/usr/bin/python
count = 0
while count < 5:
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5"3.3、for 循环语句
3.3.1、定义
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法：
for循环的语法格式如下：
for iterating_var in sequence: statements(s)
流程图：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for letter in 'Python': # 第一个实例
print("当前字母: %s" % letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print ('当前水果: %s'% fruit)
print ("Good bye!")3.3.2、通过序列索引迭代
另外一种执行循环的遍历方式是通过索引，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print ('当前水果 : %s' % fruits[index])
print ("Good bye!")3.3.3、循环使用 else 语句
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for num in range(10,20): # 迭代 10 到 20 (不包含) 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print ('%d 等于 %d * %d' % (num,i,j))
break # 跳出当前循环
else: # 循环的 else 部分
print ('%d 是一个质数' % num)3.4、循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
Python for 循环嵌套语法：
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)Python while 循环嵌套语法：
while expression:
while expression:
statement(s)
statement(s)你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。
3.5、break 语句
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
Python语言 break 语句语法：
break
流程图：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for letter in 'Python': # 第一个实例
if letter == 'h':
break
print '当前字母 :', letter
var = 10 # 第二个实例
while var > 0:
print '当前变量值 :', var
var = var -1
if var == 5: # 当变量 var 等于 5 时退出循环
break
print "Good bye!"3.6、continue 语句
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
Python 语言 continue 语句语法格式如下：
continue
流程图：
3.7、pass 语句
Python pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
Python 语言 pass 语句语法格式如下：
pass
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '当前字母 :', letter
print "Good bye!"
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!
3.8、迭代器
迭代器是一种对象，该对象包含值的可计数数字。
迭代器是可迭代的对象，这意味着您可以遍历所有值。
从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 __iter__() 和 __next__()。
3.8.1、迭代器 VS 可迭代对象（Iterable）
列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。
所有这些对象都有用于获取迭代器的 iter() 方法:
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))甚至连字符串都是可迭代的对象，并且可以返回迭代器:
mystr = "banana"
myit = iter(mystr)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))3.8.2、遍历迭代器
我们也可以使用 for 循环遍历可迭代对象:
mytuple = ("apple", "banana", "cherry")
for x in mytuple:
print(x)3.8.3、创建迭代器
要把对象/类创建为迭代器，必须为对象实现 __iter__() 和 __next__() 方法。
正如您在 Python 类/对象 一章中学到的，所有类都有名为 __init__() 的函数，它允许您在创建对象时进行一些初始化。
__iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。
__next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))3.8.4、StopIteration
如果你有足够的 next() 语句，或者在 for 循环中使用，则上面的例子将永远进行下去。
为了防止迭代永远进行，我们可以使用 StopIteration 语句。
在 __next__() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误:
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)四、python函数
在Python中，函数是一段可以被重复调用的代码块，它用于执行特定的任务或计算。函数使代码更具模块化和可读性，并允许开发者重用代码。函数通过def关键字来定义。
4.1、定义函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def function_name(parameters):
"""Docstring (可选的文档字符串，用于描述函数的功能)"""
# 函数体：包含执行特定任务的代码
return result # 可选的返回值function_name：函数的名称，它应该描述函数的功能。parameters：函数接受的参数列表，这些参数在函数体内被使用。参数是可选的，如果没有参数，则括号内为空。Docstring：一个可选的字符串，用于描述函数的用途、参数和返回值。它不是必需的，但强烈建议使用，以提高代码的可读性和可维护性。函数体：包含实际执行的代码块。return：一个可选的语句，用于从函数返回一个值。如果函数不返回值，则隐式地返回None。
4.2、调用函数
如需调用函数，请使用函数名称后跟括号:
def my_function():
print("Hello from a function")
my_function()4.3、参数
信息可以作为参数传递给函数。
参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。
下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名:
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")4.3.1、参数个数
默认情况下，必须使用正确数量的参数调用函数。 这意味着如果您的函数需要 2 个参数，则必须使用 2 个参数调用该函数，即不是更多，也不是更少。
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")此函数需要 2 个参数，并获取 2 个参数，如果您尝试使用 1 或 3 个参数调用该函数，您将收到错误消息:。
4.3.2、任意参数 *args
如果您不知道将传递给函数的参数数量，请在函数定义中的参数名称前添加 *。
这样，函数将接收 tuple 元组参数，并可以相应地访问项目:
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")Arbitrary Arguments 在 Python 文档中通常缩写为 *args。
4.3.3、Keyword Arguments 关键字参数
您还可以使用 key = value 语法发送参数。
这样参数的顺序无关紧要。
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")短语 Keyword Arguments 在 Python 文档中通常缩写为 kwargs。
4.3.4、任意关键字参数 **kwargs
如果您不知道将传递给函数的关键字实际参数的数量，请在函数定义中的形式参数名称前添加两个星号:**。
这样，函数将接收一个dictionary 字典参数，并可以相应地访问项目:
def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")Arbitrary Kword Arguments 在 Python 文档中通常缩写为 **kwargs。
4.3.5、默认参数值
下面的例子展示如何使用默认参数值。
如果我们调用了不带参数的函数，则使用默认值:
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")4.3.6、以 List 传参
您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型。
例如，如果您将 List 作为参数发送，它到达函数时仍将是 List（列表）:
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)4.3.7、返回值
如需使函数返回值，请使用 return 语句:
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))4.3.8、pass 语句
函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误。
def myfunction():
pass4.3.9、递归
Python 也接受函数递归，这意味着定义的函数能够调用自身。
递归是一种常见的数学和编程概念。它意味着函数调用自身。这样做的好处是可以循环访问数据以达成结果。
开发人员应该非常小心递归，因为它可以很容易地编写一个永不终止的，或者使用过量内存或处理器能力的函数。但是，在被正确编写后，递归可能是一种非常有效且数学上优雅的编程方法。
在这个例子中，tri_recursion() 是我们定义为调用自身 ("recurse") 的函数。 我们使用 k 变量作为数据，每次递归时递减(-1)。 当条件不大于 0 时（比如当它为 0 时），递归结束。
对于新的开发人员来说，可能需要一些时间来搞清楚其工作原理，最好的方法是测试并修改它。
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("\n\nRecursion Example Results")
tri_recursion(6)4.4、Lambda 函数
在Python中，lambda函数是一种小型匿名函数，即它没有名字。lambda函数可以接收任意数量的参数，但只能有一个表达式。它们通常用于需要将函数作为参数传递，或当函数足够简单以至于用一行代码就能表示时。
lambda函数的基本语法如下：
lambda 参数1, 参数2, ...: 表达式下面是一些lambda函数的示例和它们的用途：
示例1：简单的加法
add = lambda x, y: x + y
print(add(5, 3)) # 输出: 8示例2：在列表排序中使用
假设你有一个包含元组的列表，你想根据元组的第二个元素进行排序：
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
# 使用lambda函数作为sort的key参数
sorted_pairs = sorted(pairs, key=lambda pair: pair[1])
print(sorted_pairs)
# 输出: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]示例3：在map函数中使用
map函数可以对列表中的每个元素应用一个函数。lambda函数在这里非常有用：
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]示例4：在filter函数中使用
filter函数用于过滤序列，只保留那些应用函数后返回值为True的元素。
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 输出: [2, 4, 6, 8, 10]注意事项
lambda函数主要用于简单的情况，如果函数逻辑复杂，最好使用标准的def定义函数。lambda函数可以有任意数量的参数，但只能有一个表达式。lambda函数本身没有名称（匿名），因此不能在后续代码中被直接引用。
为何使用 Lambda 函数?
当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。
假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字:
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))五、python模块
Python 模块是包含 Python 代码的文件，这些文件可以包含函数、类和变量，以及可重用的代码。通过使用模块，你可以将代码组织得更加清晰和模块化，同时也可以方便地共享和重用代码。
5.1、创建模块
- 创建文件：创建一个
.py文件。例如，创建一个名为mymodule.py的文件。 - 编写代码：在
mymodule.py中编写一些函数、类和变量。
# mymodule.py
def greet(name):
return f"Hello, {name}!"
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"{self.name} is {self.age} years old."5.2、使用模块
导入模块：在另一个 Python 文件中导入并使用这个模块。
# main.py
import mymodule
print(mymodule.greet("Alice"))
person = mymodule.Person("Bob", 30)
print(person)5.3、模块类型
- 标准库模块：Python 自带的模块，如
os,sys,math等。 - 第三方模块：通过包管理工具（如
pip）安装的模块，如requests,numpy,pandas等。 - 自定义模块：你自己创建的模块，如上例中的
mymodule。
5.4、导入方式
- 导入整个模块：
import mymodule print(mymodule.greet("Alice")) - 导入特定部分：
from mymodule import greet, Person print(greet("Alice")) person = Person("Bob", 30) print(person) - 导入模块并重命名：
import mymodule as mm print(mm.greet("Alice")) - 导入所有内容（不推荐，容易命名冲突）：
from mymodule import * print(greet("Alice"))5.5、__name__特殊变量每个 Python 模块都有一个内置的特殊变量
__name__。当模块被直接运行时，__name__的值为"__main__"；当模块被导入时，__name__的值为模块名。# mymodule.py def greet(name): return f"Hello, {name}!" if __name__ == "__main__": print(greet("World"))当你直接运行
mymodule.py时，会输出Hello, World!。但如果你从另一个模块导入mymodule，则if __name__ == "__main__":下的代码不会执行。
5.6、包
5.6.1、定义
包是包含多个模块的目录，并且目录中必须包含一个 __init__.py 文件（可以是空的）。包允许你更有组织地管理模块。
mypackage/
__init__.py
module1.py
module2.py 你可以使用点号 . 来导入包中的模块：
import mypackage.module1
print(mypackage.module1.some_function())或者从包中导入特定的内容：
from mypackage.module1 import some_function
print(some_function())5.6.2、__init__.py
在Python中，__init__.py 文件是一个特殊文件，它存在于包的目录中，用于标记该目录作为一个Python包。这个文件可以是空的，但它也可以包含Python代码，这些代码将在包的第一次被导入时执行。
以下是一些关于 __init__.py 文件的要点：
- 包的标识：
- 当Python解释器遇到一个目录，并且该目录中包含
__init__.py文件时，它会将该目录视为一个Python包。 - 这允许你使用点（
.）语法来导入包中的模块和子包。
- 当Python解释器遇到一个目录，并且该目录中包含
- 初始化代码：
__init__.py文件可以包含初始化包的代码。- 这意味着，当包被导入时，
__init__.py中的代码将首先被执行。
- 控制导入行为：
- 通过在
__init__.py文件中定义__all__列表，你可以控制当使用from package import *语句时哪些模块和子包会被导入。 - 你还可以在
__init__.py中使用import语句来导入包内部的模块，这样它们就可以通过包名直接访问了。
- 通过在
- 包的版本和元数据：
- 虽然通常不在
__init__.py中定义，但包的版本号和元数据（如作者、许可证等）通常通过setup.py文件（用于分发和安装包的脚本）来指定。 - 然而，有时你可能会在
__init__.py文件中添加代码来动态地获取或设置包的版本信息。
- 虽然通常不在
- 空文件：
- 对于简单的包来说，
__init__.py文件可以是空的。 - 但是，即使它是空的，它的存在也是必要的，因为它告诉Python解释器该目录应该被视为一个包。
- 对于简单的包来说，
- Python 3.3+ 的隐式命名空间包：
- 从Python 3.3开始，引入了隐式命名空间包的概念，它允许你创建没有
__init__.py文件的包。 - 隐式命名空间包由多个目录组成，这些目录具有相同的名称并且都包含Python模块或子包，但它们没有共同的父目录中的
__init__.py文件。 - 这种类型的包主要用于大型项目或第三方库的扩展，其中包的不同部分可能由不同的团队或项目维护。
- 从Python 3.3开始，引入了隐式命名空间包的概念，它允许你创建没有
- Python 3.6+ 的
__pycache__和__init__.py：- 从Python 3.6开始，Python解释器在导入模块时会生成一个
__pycache__目录来存储编译后的字节码文件（.pyc）。 __init__.py文件的存在与否会影响这个目录的生成和字节码文件的存储方式。
- 从Python 3.6开始，Python解释器在导入模块时会生成一个
总的来说，__init__.py 文件在Python包中扮演着重要的角色，它不仅是包的标识，还可以包含初始化代码和控制导入行为的逻辑。然而，随着Python的发展，隐式命名空间包的引入为创建没有 __init__.py 文件的包提供了另一种选择。
六、python类和对象
在Python中，类和对象是面向对象编程（OOP）的两个核心概念。类（Class）是一个模板或蓝图，它定义了对象的属性和方法（即函数）。对象（Object）则是根据类创建的实例，它具有类所定义的属性和方法。
6.1、创建类
如需创建类，请使用 class 关键字:
class Dog:
def __init__(self, name, age):
self.name = name # 属性
self.age = age # 属性
def bark(self):
print(f"{self.name} says woof!") # 方法6.2、创建对象
对象是类的实例。当我们创建类的一个实例时，我们实际上是在内存中分配了一块空间来存储该实例的属性和方法。这个过程通常被称为实例化。
创建对象使用类名后跟括号，括号中可以包含传递给__init__方法的参数。
my_dog = Dog("Buddy", 3)在这个例子中，my_dog是Dog类的一个实例（即对象）。它包含了Dog类定义的属性和方法，并且我们可以使用点（.）语法来访问它们。
6.3、__init__() 函数
在Python中，__init__() 函数是一个特殊的方法（也称为魔术方法或双下方法），它是类的构造函数。当你创建类的新实例（即对象）时，__init__() 方法会自动被调用，用于初始化对象的属性或执行其他必要的设置。
__init__() 方法接受至少一个参数，即 self，它代表类的实例本身。通过 self，你可以访问类的属性和方法。除了 self 之外，__init__() 方法还可以接受其他参数，这些参数通常用于为对象的属性提供初始值。
下面是一个简单的例子，展示了如何定义和使用 __init__() 方法：
class Dog:
def __init__(self, name, age):
self.name = name # 设置对象的name属性
self.age = age # 设置对象的age属性
def bark(self):
print(f"{self.name} says woof!")
# 创建Dog类的一个实例
my_dog = Dog("Buddy", 3)
# 访问对象的属性
print(my_dog.name) # 输出: Buddy
print(my_dog.age) # 输出: 3
# 调用对象的方法
my_dog.bark() # 输出: Buddy says woof!在这个例子中，Dog 类有一个 __init__() 方法，它接受三个参数：self、name 和 age。self 是自动传递的，而 name 和 age 是我们在创建 Dog 类的实例时提供的。__init__() 方法使用这些参数来初始化对象的 name 和 age 属性。
需要注意的是，虽然 self 参数在调用 __init__() 方法时不需要显式传递（Python会自动处理），但在类的方法定义中，你必须始终包含它作为第一个参数。
另外，__init__() 方法不是严格必需的；如果你的类不需要初始化任何属性或执行任何设置，你可以省略它。但是，在大多数情况下，定义 __init__() 方法是一个好习惯，因为它允许你为你的对象设置初始状态。
6.4、对象方法
在Python中，类（Class）是面向对象编程（OOP）的基本构建块，它定义了对象的属性和行为。对象（Object）是类的实例，它包含了类所定义的属性和方法。方法（Method）是与对象相关联的函数，它们定义了对象可以执行的操作。
6.4.1、方法的定义
在类中，方法是通过在类体内部定义函数来创建的。方法的第一个参数始终是self，它代表类的实例本身。通过self，方法可以访问对象的属性和调用其他方法。
6.4.2、方法的类型
-
实例方法：这是最常见的方法类型，它定义在类体内部，并且需要
self参数来访问对象的属性和其他方法。 -
类方法：使用
@classmethod装饰器定义，第一个参数是cls（代表类本身，而不是实例），通常用于创建与类相关的功能，而不是与特定实例相关的功能。 -
静态方法：使用
@staticmethod装饰器定义，它们不需要self或cls参数，通常用于将普通函数与类关联起来，但不需要访问类的属性或方法。
6.4.3、实例方法的示例
class Dog:
def __init__(self, name, age):
self.name = name # 实例属性
self.age = age # 实例属性
def bark(self): # 实例方法
print(f"{self.name} says woof!")
# 创建Dog类的一个实例
my_dog = Dog("Buddy", 3)
# 调用实例方法
my_dog.bark() # 输出: Buddy says woof!在这个例子中，bark是一个实例方法，它使用self参数来访问对象的name属性。
6.4.4、类方法的示例
class Dog:
species = "Canis lupus familiaris" # 类属性
def __init__(self, name, age):
self.name = name
self.age = age
@classmethod
def get_species(cls): # 类方法
return cls.species
# 创建Dog类的一个实例
my_dog = Dog("Buddy", 3)
# 调用类方法
print(my_dog.get_species()) # 输出: Canis lupus familiaris在这个例子中，get_species是一个类方法，它使用cls参数来访问类的species属性。
6.4.5、静态方法的示例
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
@staticmethod
def describe_sound(): # 静态方法
return "Woof!"
# 创建Dog类的一个实例
my_dog = Dog("Buddy", 3)
# 调用静态方法
print(my_dog.describe_sound()) # 输出: Woof!在这个例子中，describe_sound是一个静态方法，它不需要self或cls参数，因为它既不依赖于对象的状态也不依赖于类的状态。
6.4.6、总结
- 方法是与对象相关联的函数，它们定义了对象的行为。
- 实例方法使用
self参数来访问对象的属性和其他方法。 - 类方法使用
@classmethod装饰器定义，并使用cls参数来访问类的属性和其他类方法。 - 静态方法使用
@staticmethod装饰器定义，它们不依赖于对象或类的状态。
6.5、self 参数
在Python的类中，self 参数是一个约定俗成的名称，用于表示类的实例本身。当你定义一个类的方法时，该方法的第一个参数始终是 self，它允许你访问对象的属性和调用对象的其他方法。尽管你可以使用其他名称来代替 self，但强烈建议不要这样做，因为 self 已经成为Python社区广泛接受的惯例。
6.5.1、self 的作用
-
访问实例属性：通过
self，你可以访问和修改对象的属性。 -
调用其他方法：你可以使用
self来调用同一个对象上的其他方法。 -
区分实例属性和类属性：类属性是属于类本身的，而实例属性是属于类实例（即对象）的。通过
self，你可以明确地知道你是在操作实例属性。
6.5.2、self 的使用示例
class Dog:
def __init__(self, name, age):
self.name = name # 设置实例属性name
self.age = age # 设置实例属性age
def bark(self):
print(f"{self.name} says woof!") # 使用self访问实例属性name
def get_age(self):
return self.age # 使用self返回实例属性age
# 创建Dog类的一个实例
my_dog = Dog("Buddy", 3)
# 调用方法，Python会自动传递实例本身给self参数
my_dog.bark() # 输出: Buddy says woof!
print(my_dog.get_age()) # 输出: 3 在这个例子中，__init__ 方法是一个特殊的方法，称为构造函数，它在创建对象时自动调用。它使用 self 参数来初始化对象的 name 和 age 属性。bark 和 get_age 方法也使用 self 来访问这些属性。
6.5.3、注意事项
- 当你在类的外部调用一个方法时，你不需要显式地传递
self参数。Python会自动将对象本身作为第一个参数传递给方法。 - 在类的方法定义中，
self必须是第一个参数，即使你不打算在方法体中使用它。 - 虽然你可以使用其他名称来代替
self，但这将违反Python的惯例，并可能导致代码难以理解和维护。
总之，self 在Python的类中扮演着至关重要的角色，它允许你访问和操作对象的属性和方法。通过遵循使用 self 的惯例，你可以编写出更加清晰和易于理解的面向对象代码。
6.6 操作对象属性
6.6.1、修改对象属性
您可以这样修改对象的属性:
把 p1 的年龄设置为 40:
p1.age = 40
6.6.2、删除对象属性
您可以使用 del 关键字删除对象的属性:
删除 p1 对象的 age 属性:
del p1.age
6.6.3、删除对象
使用 del 关键字删除对象:
删除 p1 对象:
del p1
6.6.4、pass 语句
class 类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。
class Person:
pass6.7、内置类属性
- __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
- __doc__ :类的文档字符串
- __name__: 类名
- __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
- __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
Python内置类属性调用实例如下：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Employee:
'所有员工的基类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__
Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function 6.8、对象销毁(垃圾回收)
Python 使用了引用计数这一简单技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量，称为一个引用计数器。
当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
a = 40 # 创建对象 <40>
b = a # 增加引用， <40> 的计数
c = [b] # 增加引用. <40> 的计数
del a # 减少引用 <40> 的计数
b = 100 # 减少引用 <40> 的计数
c[0] = -1 # 减少引用 <40> 的计数
垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（即未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。
析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print class_name, "销毁"
pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt36.9、类属性与方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错，实例不能访问私有变量6.10、单下划线、双下划线、头尾双下划线说明：
-
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
-
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
-
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
七、python类的继承
7.1、继承语法
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
继承语法
class 派生类名(基类名)
...
在python中继承中的一些特点：
- 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看： python 子类继承父类构造函数说明。
- 2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
- 3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]):
...
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
调用子类构造方法
调用子类方法
调用父类方法
父类属性 : 200
你可以继承多个类
class A: # 定义类 A ..... class B: # 定义类 B ..... class C(A, B): # 继承类 A 和 B .....
7.2、继承步骤
7.2.1、创建父类
任何类都可以是父类，因此语法与创建任何其他类相同:
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
#Use the Person class to create an object, and then execute the printname method:
x = Person("John", "Doe")
x.printname()7.2.2、创建子类
class Student(Person):
pass如果您不想向该类添加任何其他属性或方法，请使用 pass 关键字。
7.2.3、添加 __init__() 函数
class Student(Person):
def __init__(self, fname, lname):
#add properties etc.当您添加 __init__() 函数时，子类将不再继承父的 __init__() 函数。
注释: 子的 __init__() 函数会覆盖对父的 __init__() 函数的继承。
如需保持父的 __init__() 函数的继承，请添加对父的 __init__() 函数的调用:
class Student(Person):
def __init__(self, fname, lname):
Person.__init__(self, fname, lname)7.2.4、使用 super() 函数
Python 还有一个 super() 函数，它会使子类从其父继承所有方法和属性:
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。
7.2.5、添加属性
把名为 graduationyear 的属性添加到 Student 类:
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
self.graduationyear = 2019在这例子中，2019 年应该是一个变量，并在创建 student 对象时传递到 Student 类。为此，请在 __init__() 函数中添加另一个参数:
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
x = Student("Mike", "Olsen", 2019)7.3、方法重写
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Parent: # 定义父类
def myMethod(self):
print '调用父类方法'
class Child(Parent): # 定义子类
def myMethod(self):
print '调用子类方法'
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
调用子类方法7.4、基础重载方法
下表列出了一些通用的功能，你可以在自己的类重写：
| 序号 | 方法, 描述 & 简单的调用 |
|---|---|
| 1 | __init__ ( self [,args...] ) 构造函数 简单的调用方法: obj = className(args) |
| 2 | __del__( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj |
| 3 | __repr__( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj) |
| 4 | __str__( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj) |
| 5 | __cmp__ ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x) |
7.5、运算符重载
Python同样支持运算符重载，实例如下：
#!/usr/bin/python
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
Vector(7,8)参考：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
