菜鸟Python

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。

Python3 基础语法

• 编码：
  • 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。
• 标识符：
  • 对大小写敏感。
• python保留字：
  
• 注释：
  • 单行注释以 # 开头
  • 多行注释可以用多个 # 号，还有 ‘’’ 和 “”"
• 行与缩进：
  • python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}
  • 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
• 多行语句：
  • Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
  • 在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \
• 数字(Number)类型：
  • python中数字有四种类型：整数（只有int，没有long）、布尔型、浮点数和复数（ 如 1 + 2j、 1.1 + 2.2j）。
• 字符串(String)：
  • Python 中单引号 ’ 和双引号 " 使用完全相同。
    使用三引号(‘’’ 或 “”")可以指定一个多行字符串。
  • 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
  • 按字面意义级联字符串，如 "this " "is " “string” 会被自动转换为 this is string。
  • 字符串可以用 + 运算符连接在一起，用 * 运算符重复
  • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
  • Python 中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
• print输出：
  • print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=“”
• import 与 from…import：
  • 前者是导入整个模块，后者是从模块中导入函数
  • 将整个模块(somemodule)导入，格式为： import somemodule
  • 从某个模块中导入某个函数,格式为： from somemodule import somefunction
  • 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
  • 将某个模块中的全部函数导入，格式为： from somemodule import *

Python3基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

• Python允许你同时为多个变量赋值。
• 也可以为多个对象指定多个变量：

  a, b, c = 1, 2, "runoob"

• 标准数据类型：

• 内置的 type() 函数可以用来查询变量所指的对象类型。
  
• 此外还可以用 isinstance 来判断.

isinstance(111, int)

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）。
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
• 此外还有一些高级的数据类型，如: 字节数组类型(bytes)。
• Number（数字）：int、float、bool、complex。
  • Python3 中，bool 是 int 的子类。
  • 复数由实数部分和虚数部分构成，可以用 a + bj，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
  • 数值运算：
    • 2 / 4 # 除法，得到一个浮点数
    • 2 // 4 # 除法，得到一个整数
    • 2 ** 5 # 乘方
• String（字符串）：
  • Python 没有单独的字符类型，一个字符就是长度为1的字符串。
  • 与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。
• List（列表）是写在方括号 [] 之间、用逗号分隔开的元素列表。
  • 列表是有序的对象集合
  • 列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
  • 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
  • List中的元素是可以改变的。
  • Python 列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数表示逆向读取。
    以下实例用于翻转字符串：

def reverseWords(input):
    inputWords = input.split(" ")
    #通过空格将字符串分开，把各个单词分隔为列表
    inputWords = inputWords[-1::-1]
    output = ' '.join(inputWords)
    #重新组合字符串
    return output

if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)

• Tuple（元组）与列表类似，不同之处在于元组的元素不能修改。
  • 元组写在小括号 () 里。元素之间用逗号隔开，元组中的元素类型也可以不相同。
  • 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
  • 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

    tup1=() #空元组
    tup2=(20,) #一个元素，需要在元素后面添加逗号

• string、list 和 tuple 都属于 sequence（序列）
• Set（集合）是一种无序、可变的数据类型，用于存储唯一的元素。
  • 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
  • 集合使用大括号 {} 表示，元素之间用逗号 , 分隔。
  • 另外，也可以使用 set() 函数创建集合。创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
    创建格式：

  parame = {value01,value02,...}
  #或者
  set(value)

• Dictionary（字典）是无序的对象集合，字典当中的元素是通过键来存取的，而不是通过偏移存取。
  • 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
  • 键(key)必须使用不可变类型。
  • 在同一个字典中，键(key)必须是唯一的。
  • 创建空字典使用 { }。
  • 另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。
• bytes 类型表示的是不可变的二进制序列。

  • 与字符串类型不同的是，bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

  • bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

  • 创建 bytes 对象的方式有多种，最常见的方式是使用 b 前缀。

  • 此外，也可以使用 bytes() 函数将其他类型的对象转换为 bytes 类型。bytes() 函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码。

     x =bytes("hello",encoding = "utf-8")
    

  • Bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于 bytes 类型是不可变的，因此在进行修改操作时需要创建一个新的 bytes 对象。

• Python数据类型转换
  • int(x [,base])：将x转换为一个整数
  • complex(real [,imag])：创建一个复数
  • repr(x)：将对象 x 转换为表达式字符串
  • eval(str)：用来计算在字符串中的有效Python表达式,并返回一个对象
  • frozenset(s)：转换为不可变集合
  • ord(x)：将一个字符转换为它的整数值
  • hex(x)：将一个整数转换为一个十六进制字符串
  • oct(x)：将一个整数转换为一个八进制字符串

Python3数据类型转换

• Python 数据类型转换可以分为两种：隐式类型转换 - 自动完成；显式类型转换 - 需要使用类型函数来转换。
• 整型和字符串类型运算结果会报错

Python3解释器

这个与Linux/Unix的系统有关。
其解释器不止一种。

Python3注释

• 单行注释以#开头
• 多行注释用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来

Python3 运算符

• 2**5代表2的5次方。
• //是取整除，往小的方向取整。
• $:=$ 是海象运算符，可在表达式内部为变量赋值。
• Python位运算符：
  • & 是按位与 (逻辑运算符 and )
  • | 按位或（逻辑运算符 or ）
  • ^ 按位异或
  • ~ 按位取反（逻辑运算符 not）
  • $<<$ 左移
  • $>>$ 右移
• Python成员运算符：
  • in ，如果在指定的序列中找到值返回 True，否则返回 False。
  • not in， 如果在指定的序列中没有找到值返回 True，否则返回 False。
• Python身份运算符：
  • is， is 是判断两个标识符是不是引用自一个对象。x is y，类似id(x) == id(y)。
  • is not， is not 是判断两个标识符是不是引用自不同对象。
  • 注：id() 函数用于获取对象内存地址。
  • is 与 == 的区别在于，is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
• Python运算符优先级：
  1. 圆括号，中括号，大括号的表达式
  2. 读取，切片，调用，属性引用
  3. await表达式
  4. **
  5. +x,-x,~x
  6. *,@(这是矩阵乘)，/，//，%
  7. +，-
  8. 移位运算
  9. 与
  10. 异或
  11. 或
  12. 比较运算，包括成员检测和标识号检测
  13. 非
  14. 与
  15. 或
  16. 条件表达式 if-else
  17. lambda表达式
  18. 赋值表达式 $:=$

Python 数字

• 数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
• 注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
• 变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误。
• 在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。此处， _ 变量应被用户视为只读变量。
• 数学函数：
  • ceil(x): 返回数字的上入整数。
  • exp(x)：返回e的x次幂($e^x$),。
  • fabs(x):以浮点数形式返回数字的绝对值。
  • floor(x):返回数字的下舍整数。
  • log(x)：math.log(100,10)返回2.0。
  • log10(x)：返回以10为基数的x的对数。
  • modf(x)：返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
  • round(x [,n])：返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
• 随机数函数 ：
  • 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]范围内。
• 三角函数：
  • atan2(y, x)：返回给定的 X 及 Y 坐标值的反正切值。
  • hypot(x, y)：返回欧几里德范数 sqrt(xx + yy)。
  • degrees(x)：将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0。
  • radians(x)：将角度转换为弧度。

Python3 字符串

• 注意索引与截取的区别：
  
• 可以截取字符串的一部分并与其他字段拼接：

 var1 = 'Hello World!'
print("已更新字符串：",var1[ : 6] + ''Runoob!')

• Python转义字符：
  • \ 在行尾时代表续行符
  • \a 是响铃
  • \b 是退格
  • \000 是空
  • \f 是换页
  • \yyy 是八进制数，y代表0~7的字符，例如：\012 代表换行。
  • \xyy 是十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
  • \v 是纵向制表符
  • \t 是横向制表符
  • \other 其它的字符以普通格式输出
  • \r 是回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。

   print('google runoob taobao\r123456')
   #结果为123456 runoob taobao

binary_number = bin(decimal_number)  # 十进制转换为二进制
octal_number = oct(decimal_number)  # 十进制转换为八进制
hexadecimal_number = hex(decimal_number)  # 十进制转换为十六进制

• [] 通过索引获取字符串中字符；[ : ] 截取字符串中的一部分，遵循左闭右开原则。
• Python字符串格式化：
  • %p 用十六进制数格式化变量的地址
  • %e 用科学计数法格式化浮点数
  • 在正数前面显示空格
  • % ‘%%‘输出一个单一的’%’
  • (var) 映射变量(字典参数)
• Python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
• f-string：（这个是3.6之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。）f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去。

name = 'Runoob'
print(f'Hello{name}')
#替换变量
print(f'{1+2}')
#使用表达式

w = {'name': 'Runoob','url':'www.runoob.com'}
print(f'{w["name"]}:{w["url"]}')

• Unicode字符串使用的语法是在字符串前面加上前缀 u，在Python3中，所有的字符串都是Unicode字符串。（在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串）
• Python的字符串内建函数：

  • capitalize()
    将字符串的第一个字符转换为大写

  • center(width, fillchar)
    返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

  • count(str, beg= 0,end=len(string))
    返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数。

  • bytes.decode(encoding=“utf-8”, errors=“strict”)
    Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

  • encode(encoding=‘UTF-8’,errors=‘strict’)
    以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’

  • endswith(suffix, beg=0, end=len(string))
    检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是以 suffix 结束，返回 True,否则返回 False。

  • expandtabs(tabsize=8)
    把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。

  • find(str, beg=0, end=len(string))
    检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1。

  • rfind(str, beg=0,end=len(string))
    类似于 find()函数，不过是从右边开始查找.

  • index(str, beg=0, end=len(string))
    跟find()方法一样，只不过如果str不在字符串中会报一个异常。同理rindex是从右边开始。

  • isalnum()
    如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。

  • isalpha()
    如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False。

  • isdigit()
    如果字符串只包含数字则返回 True ，否则返回 False。

  • islower()
    如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。

  • isupper()
    如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

  • isnumeric()
    如果字符串中只包含数字字符，则返回 True，否则返回 False。

  • isspace()
    如果字符串中只包含空白，则返回 True，否则返回 False。

  • isdecimal()
    检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

  • join(seq)
    以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。

  • ljust(width[, fillchar])
    返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。rjust是右对齐。

  • lower()
    转换字符串中所有大写字符为小写。同理upper()是小写转为大写。

  • lstrip()
    截掉字符串左边的空格或指定字符。rstrip是删除右边的。strip([chars])指在字符串上执行 lstrip()和 rstrip()。

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

  • max(str)
    返回字符串 str 中最大的字母。同理min(str)是返回最小的字母。

  • replace(old, new [, max])
    将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

  • split(str=“”, num=string.count(str))
    以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。

  • splitlines([keepends])
    按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

  • startswith(substr, beg=0,end=len(string))
    检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

  • swapcase()
    将字符串中大写转换为小写，小写转换为大写。

  • translate(table, deletechars=“”)
    根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。

  • zfill (width)
    返回长度为 width 的字符串，原字符串右对齐，前面填充0。

Python3 列表

• 可以使用 append() 方法来添加列表项，list.append(obj)可以在列表末尾添加新的对象。
• 列表使用方括号 [ ]
• 可以使用 del 语句来删除列表的的元素
• 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,end=" ")#1 2 3

• Python列表截取与拼接

L=['Google', 'Runoob', 'Taobao']
L[2] #	'Taobao'
#其他的省略
squares = [1, 4, 9, 16, 25]
squares += [36, 49, 64, 81, 100]
#squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 嵌套列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]   #x[['a', 'b', 'c'], [1, 2, 3]]
x[0]   #['a', 'b', 'c']
x[0][1]  #'b'

• 列表比较

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
#结果：
#operator.eq(a,b):  False
#operator.eq(c,b):  True

• Python 列表函数&方法
  函数：
  • len(list)
    列表元素个数
  • max(list)
    返回列表元素最大值
  • min(list)
    返回列表元素最小值
  • list(seq)
    将元组转换为列表
    方法：
  • list.count(obj)
    统计某个元素在列表中出现的次数
  • list.extend(seq)
    在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
  • list.index(obj)
    从列表中找出某个值第一个匹配项的索引位置
  • list.insert(index, obj)
    将对象插入列表
  • list.pop([index=-1])
    移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
  • list.remove(obj)
    移除列表中某个值的第一个匹配项
  • list.reverse()
    反向列表中元素
  • list.sort( key=None, reverse=False)
    对原列表进行排序
  • list.clear()
    清空列表
  • list.copy()
    复制列表

Python3 元组

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组的不可变指的是元组所指向的内存中的内容不可变。
  重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

tup = ('liu','lian')
tup[0] = 'zhao'
'''
Traceback (most recent call last):
  File "d:/CodeTest/one.py", line 2, in <module>
    tup[0] =' zhao'
TypeError: 'tuple' object does not support item assignment
'''

tup=('liu','lian')
print(id(tup))

tup = ('zhao', 'meng')
print(id(tup))

'''
2622267162760
2622267447752
'''

• 可以对元组进行连接组合： tup3 = tup1 + tup2
• 元组使用小括号 ()
• 括号中元素使用逗号隔开
• 创建空元组使用：tup = ()

 tup = "a", "b", "c", "d"   #  不需要括号也可以
 type(tup) #<class 'tuple

• 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素。
• 元组之间可以使用 +、+=和 * 号进行运算，其他使用方式类似列表。

 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,end=" ")#1 2 3

• tuple(iterable)
  将可迭代系列转换为元组。

Python3 字典

• 字典是另一种可变容器模型，且可存储任意类型对象。
  • 字典的每个键值 $key=>value$ 对用冒号 $:$ 分割，每个对之间用逗号$,$ 分割,整个字典包括在花括号 {} 中 。
  • 注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
  • 键必须是唯一的，创建时如果同一个键被赋值两次，后一个值会被记住。值则不必唯一，值可以取任何数据类型。
  • 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

  d = {key1 : value1, key2 : value2, key3 : value3 }

• 创建空字典：使用大括号 { } 创建

EmptyDict = {}
print(type(EmptyDict))
# <class 'dict'>

• 访问字典里的值：把相应的键放入到方括号中
  • 如果用字典里没有的键访问数据，会输出错误
• 修改字典：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值
• 删除字典元素：能删单一的元素也能清空字典，清空只需一项操作，即clear()；显式删除一个字典用del命令

del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

• 字典内置函数与方法：
  • str(dict)
    输出字典，可以打印的字符串表示。
  • dict.clear()
    删除字典内所有元素
  • dict.copy()
    返回一个字典的浅复制
  • dict.fromkeys()
    创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
  • dict.get(key, default=None)
    返回指定键的值，如果键不在字典中返回 default 设置的默认值
  • key in dict
    如果键在字典dict里返回true，否则返回false
  • dict.items()
    以列表返回一个视图对象
  • dict.keys()
    返回一个视图对象
  • pop(key[,default])
    删除字典 key（键）所对应的值，返回被删除的值。
  • popitem()
    返回并删除字典中的最后一对键和值。

Python3 集合

• 集合（set）是一个无序的不重复元素序列，可以进行交集、并集、差集等常见的集合操作。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
 print(basket)       # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}

• 可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
  • 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

  parame = {value01,value02,...}
  #或者
  set(value)
  set1 = {1,2,3,4} #example1
  set2 = ([4,5,6,7]) #example2

• 添加元素：s.add( x )将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)
#{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，即s.update( x )， x 可以有多个，用逗号分开。

thisset = set(("Google", "Runoob", "Taobao")) 
thisset.update({1,3})
print(thisset)
#{1, 3, 'Google', 'Taobao', 'Runoob'} 
thisset.update([1,4],[5,6])  
print(thisset)
#{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

• 移除元素s.remove( x )，将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
  此外还有一个方法s.discard( x )也是移除集合中的元素，且如果元素不存在，不会发生错误。
  我们也可以设置随机删除集合中的一个元素，语法格式如下：s.pop() ，set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
• 计算集合元素个数len(s)
• 清空集合s.clear()
• 判断元素是否在集合中存在 x in s
  • add() 添加元素
  • copy()拷贝一个集合
  • difference()返回多个集合的差集
  • difference_update()移除集合中的元素，该元素在指定的集合也存在。
  • discard() 删除集合中指定的元素
  • intersection() 返回集合的交集
  • intersection_update() 返回集合的交集
  • isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
  • issubset() 判断指定集合是否为该方法参数集合的子集
  • issuperset() 判断该方法的参数集合是否为指定集合的子集
  • symmetric_difference() 返回两个集合中不重复的元素集合。
  • symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
  • union() 返回两个集合的并集
  • update() 给集合添加元素

Python3 条件控制

• Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 在 Python 中没有 switch…case 语句，但在 Python3.10 版本添加了 match…case，功能也类似，match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开。

Python3循环语句

• 在 Python 中没有 do…while 循环。
• 我们可以通过设置条件表达式永远不为 false 来实现无限循环
  • 你可以使用 CTRL+C 来退出当前的无限循环
  • 无限循环在服务器上客户端的实时请求非常有用
  • for循环实例:

 sites = ["Baidu","Google","Runoob","Taobao"]
for site in sites:
    print(site)
 '''
Baidu
Google
Runoob
Taobao
'''
#也可以用于打印字符串的中的每个字符
word = '刘恋'

for letter in word:
    print(letter)
'''
刘
恋
'''
#整数范围可以配合range()函数使用
for number in range(1,6):
    print(number)
'''
1
2
3
4
5
'''

• 在 Python 中，for…else 语句用于在循环结束后执行一段代码。

for item in iterable:
    # 循环主体
    #如果这里使用了break语句，将会跳出当前循环，不执行else子句。
else:
    # 循环结束后执行的代码

• range函数：
  • 如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列。
  • 你也可以使用 range() 指定区间的值
  • 还可以使用 range() 函数来创建一个列表
    • 如list(range(5)) #[0,1,2,3,4]
  • 也可以使 range() 以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做步长，
    • 如for i in range（0，10，3）
    • 如for i n range(-10,-100,-30)
  • 可以结合 range() 和 len() 函数以遍历一个序列的索引:

 a = ['liulian','zhaomeng','yuwenwen','tangshiyi','zhujiejing']
for i in range(len(a)):
    print(i,a[i])
 '''
0 liulian
1 zhaomeng
2 yuwenwen
3 tangshiyi
4 zhujiejing
'''

• pass语句是空语句，是为了保持程序结构的完整性。
  pass不做任何事情，一般用做占位语句。

Python 推导式

• Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
• Python 支持各种数据结构的推导式：
  • 列表(list)推导式
  • 字典(dict)推导式
  • 集合(set)推导式
  • 元组(tuple)推导式
• 列表推导式 ：
  • [表达式 for 变量 in 列表]
  • [表达式 for 变量 in 列表 if 条件]

names = ['Liulian','Zhaomeng','Yuwenwen','Tangshiyi','Zhujiejing']
new_names = [name.upper() for name in names if len(name) > 7]
#过滤掉长度小于或等于7的字符串列表，并将剩下的转换成大写字母
print(new_names)
#['ZHAOMENG', 'YUWENWEN', 'TANGSHIYI', 'ZHUJIEJING']

multiples = [ i for i in range(30) if i % 3 == 0]
print(multiples)
# 计算 30 以内可以被 3 整除的整数：
# [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

• 字典推导式：
  • { key_expr: value_expr for value in collection }
  • { key_expr: value_expr for value in collection if condition }
    listdemo = [‘liulian’,‘yintai’,‘cunlv’]

# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key:len(key) for key in listdemo}
print(newdict)
#{'liulian': 7, 'yintai': 6, 'cunlv': 5}

dic = {x:x**2 for x in {2,4,6}}
#提供三个数字，以三个数字为键，三个数字的平方为值来创建字典
print(dic)
print(type(dic))
#{2: 4, 4: 16, 6: 36}
#<class 'dict'>

• 集合推导式：
  • { expression for item in Sequence }
  • { expression for item in Sequence if conditional }

setnew = {i**2 for i in (1,2,3)}
#计算数字1，2，3的平方数
print(setnew)
#{1, 4, 9}

a = {x for x in 'abracadabra' if x not in 'abc'}
#判断不是abc的字母并输出
print(a)
print(type(a))

#{'r', 'd'}
#<class 'set'>

• 元组推导式 （生成器表达式）：
  • 元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
  • 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []。
  • 元组推导式返回的结果是一个生成器对象。

 a = (x for x in range(1,10))
 #生成一个包含数字1~9的元组
 print(a) #返回的是生成器对象
 #<generator object <genexpr> at 0x0000029C38DB3D48>
 print(tuple(a))
 #(1, 2, 3, 4, 5, 6, 7, 8, 9)

Python3 迭代器与生成器

• 迭代器：
  • 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
  • 迭代器有两个基本的方法：iter() 和 next()。
  • 字符串，列表或元组对象都可用于创建迭代器。

list = [1,2,3,4]
it = iter(list)  #创建迭代器对象
print(next(it)) #输出迭代器的下一个元素
print(next(it))
'''
1
2
'''
list = [1,2,3,4]
it = iter(list)
for x in it:
    print(x,end = ' ')
'''
1 2 3 4
'''

import sys
list = [1,2,3,4]
it = iter(list)

while True:
    try:
        print(next(it))
    except  StopIteration:
        sys.exit()
'''
1
2
3
4
'''

• 创建一个迭代器：
  • 把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()
    • __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了__next__() 方法并通过 StopIteration 异常标识迭代的完成
    • __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象
  • 类都有一个构造函数，Python 的构造函数为__init__(), 它会在对象初始化的时候执行
    class MyNumbers:
    #创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

    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))
'''
1
2
3
4
5
'''

• Stoplteration:
  • StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况
  • 在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

  class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    
    def __next__(self):
        if self.a <= 5:
        #在 5 次迭代后停止执行
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)

'''
1
2
3
4
5
'''

• 生成器：
  • 在 Python 中，yield 是一个关键字，用于定义生成器函数，使用了 yield 的函数被称为生成器
  • 当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回
  • 每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句
  • 生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果
  • 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作
  • 调用一个生成器函数，返回的是一个迭代器对象

下面实例中，countdown 函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。

在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。

通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。

  def countdown(n):
    while n > 0:
        yield n
        n -= 1
#创建生成器对象
generator = countdown(5)

#通过迭代生成器获取值
print(next(generator)) #5
print(next(generator)) #4
print(next(generator)) #3

#使用for循环迭代生成器
for value in generator:
    print(value)  #2  #1

以下实例使用yield实现斐波那契数列：

import sys

def fibonacci(n): #生成器函数--斐波那契
    a,b,counter = 0,1,0
    while True:
        if(counter > n):
            return 
        yield a
        a,b = b, a+b
        counter += 1
f = fibonacci(10)  #f是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f),end=" ")
    except StopIteration:
        sys.exit()
#0 1 1 2 3 5 8 13 21 34 55 

Python3 函数

• 定义一个函数：
  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号 : 起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

  def 函数名（参数列表）:
    函数体
    #默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

• 函数调用：
  • 函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
• 参数传递：
  • 在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的

a = [1,2,3]
a = 'Runoob'
'''
[1,2,3]是list类型
'runoob'是string类型
而变量a没有类型 她仅仅是一个对象的引用(一个指针),可以是指向List类型对象,也可以是指向String类型对象
'''

• 可更改（mutable）与不可更改（immutable）对象：
  • 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
    • 变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
    • 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
    • 不可变类型参数的传递类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
    • 可变类型参数的传递类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
      注：python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

#传不可变对象实例
def change(a):
    print(id(a))# 通过id()函数来查看内存地址变化
    a = 10
    print(id(a))

a = 1
print(id(a))
change(a)

'''
140728194400528
140728194400528
140728194400816
'''

#可变对象实例
def changeme(mylist):
    "修改传入的列表"
    mylist.append([1,2,3,4])
    print("函数内取值： ",mylist)
    return 
mylist = [10,20,30]
changeme(mylist)
print("函数外取值： ",mylist)
'''
函数内取值：  [10, 20, 30, [1, 2, 3, 4]]
函数外取值：  [10, 20, 30, [1, 2, 3, 4]]
'''

• 参数：
  • 必须参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
  • 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
  • 默认参数
  • 不定长参数

#关键字参数示例：
def printme(str):
    "打印任何传入的字符串"
    print(str)
    return 


#调用printme函数
printme(str = 'liulian')
#liulian

#不需要使用指定顺序
def printinfo(name , birthday):
    "打印任何传入的字符串"
    print("名字：",name)
    print("生日：",birthday)
    return 

printinfo( birthday='0426',name='liulian')
'''
名字： liulian
生日： 0426
'''

• 调用函数时，如果没有传递参数，则会使用默认参数。
  如def printinfo( name, age = 35 )

• 不定长参数能处理比当初声明时更多的参数，基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

 def printinfo(arg1,*vartuple):
    "打印任何传入的参数"
    print("输出：")
    print(arg1)
    print(vartuple)

printinfo(70,60,50)
'''
输出：
70
(60, 50)
'''

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
def printinfo(arg1,*vartuple):
    "打印任何传入的参数"
    print("输出：")
    print(arg1)
    for var in vartuple:
        print(var)
    return 
printinfo(10)
printinfo(70,60,50)
'''
输出：
10
输出：
70
60
50
'''

还有一种就是参数带两个星号加了两个星号，** 的参数会以字典的形式导入。 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

def printinfo(arg1, **vardict):
    "打印任何传入的参数"
    print("输出： ")
    print(arg1)
    print(vardict)

printinfo(1,a=2,b=3)

'''
输出： 
1
{'a': 2, 'b': 3}
'''

声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 *，则星号 * 后的参数必须用关键字传入。

def f(a,b,*,c):
    return a+b+c
print(f(1,2,3))
'''
Traceback (most recent call last):
  File "d:/CodeTest/one.py", line 3, in <module>
    print(f(1,2,3))
TypeError: f() takes 2 positional arguments but 3 were given
'''

def f(a,b,*,c):
    return a+b+c
print(f(1,2,c=3))
#6

• 匿名函数：
  • Python 使用 lambda 来创建匿名函数。
    所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
  • lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。
  • 语法如下：lambda [arg1 [,arg2,…argn]]:expression

#设置参数a加上10
x = lambda a:a+10
print(x(5)) #15

#以下实例匿名函数设置两个参数：
sum = lambda arg1,arg2:arg1 + arg2

print(sum(4,26)) #30
print(sum(12,18))#30

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

#以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数
def myfunc(n):
    return lambda a:a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(4))#8
print(mytripler(4))#12

• return语句用于退出函数。
• 强制位置参数，Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

 # 在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
 def f(a,b,/,c,d,*,e,f):
     print(a,b,c,d,e,f)
 
 f(10,20,30,d=40,e=50,f=60) #正确使用方式

Python3 数据结构

• 列表可以被当做堆栈使用，用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

stack = [3,4,5]
stack.append(6)
stack.append(7)
print(stack) #[3,4,5,6,7]

stack.pop()
print(stack)#[3,4,5,6]

stack.pop()
print(stack) #[3,4,5]

• 列表可以被当作队列用，但拿列表作队列效率不高

from collections import deque
queue = deque(['Eric','John','Michael'])
queue.append('Terry')
queue.append('Graham')
print(queue) #deque(['Eric', 'John', 'Michael', 'Terry', 'Graham'])
queue.popleft()
print(queue) #deque(['John', 'Michael', 'Terry', 'Graham'])
queue.popleft()
print(queue) #deque(['Michael', 'Terry', 'Graham'])

• 列表推导式提供了从序列创建列表的简单途径。
  • 通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
  • 每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。
    如果希望表达式推导出一个元组，就必须使用括号。

vec = [2,4,6]
list = [3*x for x in vec]
print(list) # [6,12,18]

vec = [2,4,6]
list = [[x,x**2] for x in vec]
print(list)
#[[2, 4], [4, 16], [6, 36]]

#对序列里每一个元素逐个调用某方法

freshfruit = ['  banana ',' loganberry ',' passion fruit  ']
list = [weapon.strip() for weapon in freshfruit]
print(list)
#['banana', 'loganberry', 'passion fruit']

#可以使用if子句作为过滤器
vec = [2,4,6]
list = [3*x for x in vec if x > 3]
print(list) #[12,18]
list2 = [3*x for x in vec if x < 2]
print(list2) #[]

#一些关于循环和其他技巧的展示
vec1 = [2,4,6]
vec2 = [4,3,-9]
list = [x*y for x in vec1 for y in vec2]
print(list)
#[8, 6, -18, 16, 12, -36, 24, 18, -54]
list2 = [vec1[i] * vec2[i] for i in range(len(vec1))]
print(list2)
#[8, 12, -54]

list = [str(round(355/113,i)) for i in range(1,6)]
print(list)
#['3.1', '3.14', '3.142', '3.1416', '3.14159']

• 嵌套列表解析：

#以下实例展示了把3X4的矩阵列表转换为4x3的列表
matrix = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]

list = [[row[i] for row in matrix] for i in range(4)]
print(list)
#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

matrix = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
]

#另一种实现方法

transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
print(transposed)

#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• del语句可以从一个列表中根据索引来删除一个元素，而不是值来删除元素。
  可以用 del 语句从列表中删除一个切割，或清空整个列表。
  • del a[0]
  • del a[2:4]
  • del a[ : ]
• 元组和序列，元组由若干逗号分隔的值组成。
  元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

t = 12345,54321,'hello!'
print(t[0])
# 12345
print(t)
# (12345, 54321, 'hello!')
u = t,(1,2,3,4,5)
print(u)
# ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

• 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来

knights = {'gallahad':'the pure','robin':'the brave'}
for k,v in knights.items():
    print(k,v)
    '''
gallahad the pure
robin the brave
    '''

• 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i,v)
    '''
0 tic
1 tac
2 toe
    '''

• 同时遍历两个或更多的序列，可以使用 zip() 组合

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail','blue']
for q,a in zip(questions,answers):
    print('What is your {0}? It is {1}.'.format(q,a))
    '''
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
    '''

• 要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

for i in reversed(range(1,10,2)):
    print(i)
    '''
9
7
5
3
1
    '''

• 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值

basket = ['apple', 'orange', 'apple', 'pear', 'orange','banana']
for f in sorted(set(basket)):
    print(f)
    '''
apple
banana
orange
pear
    '''

Python3 模块

• 一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。
• 模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
• 还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。
• 一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。每个模块都有一个__name__属性，当其值是__main__时，表明该模块自身在运行，否则是被引入。
• 内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回：
  

Python3 输入和输出

• Python输出值的方式:
  • 表达式语句
  • print() 函数。
  • 第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
  • 如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
  • 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
    • str()： 函数返回一个用户易读的表达形式。
    • repr()： 产生一个解释器易读的表达形式。

rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

  for x in range(1,11):
    print(repr(x).rjust(2),repr(x*x).rjust(3),end=' ')
    print(repr(x*x*x).rjust(4))

for x in range(1,11):
    print('{0:2d} {1:3d} {2:4d}'.format(x,x*x,x*x*x))

以上两个代码作用相同，得到的结果均为

 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

• zfill()方法，它会在数字的左边填充 0，如print(‘12’.zfill(5))执行后会输出00012。
• str.format()的基本使用如下，括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换：

print('{}网址："{}!"'.format('菜鸟教程','www.runoob.com'))
#菜鸟教程网址："www.runoob.com!"

在括号中的数字用于指向传入对象在 format() 中的位置：

print('{0} 和 {1}'.format('liulian','zhaomeng'))#liulian 和 zhaomeng
print('{1} 和 {0}'.format('liulian','zhaomeng'))#zhaomeng 和 liulian

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数：

print('{name}网址:{site}'.format(name = '菜鸟教程',site = 'www.runoob.com'))
#菜鸟教程网址:www.runoob.com

位置及关键字参数可以任意的结合:

print('站点列表{0},{1}和{other}。'.format('Google','Runoob',other = 'Taobao'))
#站点列表Google,Runoob和Taobao。

!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化
可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：

import math
print('常量PI的值近似为:{!r}。'.format(math.pi))
#常量PI的值近似为:3.141592653589793。
print('常量PI的值近似为:{0:3f}。'.format(math.pi))
#常量PI的值近似为:3.141593。

在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用：

table = {'liulian':1, 'yuwenwen':2, 'zhaomeng':3}
for name, number in table.items():
    print('{0:10} ==> {1:10d}'.format(name,number))
    '''
liulian    ==>          1
yuwenwen   ==>          2
zhaomeng   ==>          3
    '''

Python3 File

• python open() 方法用于打开一个文件，并返回文件对象。
  • 在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
  • 注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
  • open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
    参数有：
    • file: 必需，文件路径（相对或者绝对路径
    • mode: 可选，文件打开模式
    • buffering: 设置缓冲
    • encoding: 一般使用utf8
    • errors: 报错级别
    • newline: 区分换行符
    • closefd: 传入的file参数类型
    • opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• file对象
  • file.flush()
    刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
  • file.fileno()
    返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
  • file.isatty()
    如果文件连接到一个终端设备返回 True，否则返回 False
  • file.truncate([size])
    从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。

Python3 OS文件/目录方法

略过

Python3 错误和异常

• Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
• 异常捕捉可以使用 try/except 语句。
  • 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
  • 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
  • 一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
  • 一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):
    pass

• 最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

 import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

• try/except…else
  

  • try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
  • else 子句将在 try 子句没有发生任何异常的时候执行。
  • 使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。

• try-finally语句
  

• Python 使用 raise 语句抛出一个指定的异常。

  • raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

raise [Exception [, args [, traceback]]]

• 用户自定义异常

  • 你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。
  • 大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

• 定义清理行为

  • try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。

• 预定义的清理行为

  • 一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。
  • 关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法，以下这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。:

   with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

Python3 面向对象

• 类定义
  • 创建一个类之后，可以通过类名访问其属性。

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

• 类对象
  • 类对象支持两种操作：属性引用和实例化。
  • 类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样
  • 类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。

  def __init__(self):
    self.data = []

如下实例化类 MyClass，对应的 init() 方法就会被调用:

x = MyClass()

当然， __init__() 方法可以有参数，参数通过__init__() 传递到类的实例化操作上。

• 在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
• 方法重写：

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

• 类的属性与方法：

  • 类的私有属性：
    __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
  • 类的方法：
    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
    self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。
  • 类的私有方法：
    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
  • 类的专有方法：
    • init : 构造函数，在生成对象时调用
    • repr : 打印，转换
    • setitem : 按照索引赋值
    • getitem: 按照索引获取值
    • call: 函数调用
    • truediv: 除运算

• 运算符重载

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)

Python3 命名空间和作用域

• 命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。
• 命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
  一般有三种命名空间：
  • 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
  • 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
  • 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
    
    假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间 -> 全局命名空间 -> 内置命名空间。
    如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常:

Python3 标准库概览

• 以下是一些 Python3 标准库中的模块：
  • os 模块：os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
  • sys 模块：sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的信息。
  • time 模块：time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等。
  • datetime 模块：datetime 模块提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等。
  • random 模块：random 模块提供了生成随机数的函数，例如生成随机整数、浮点数、序列等。
  • math 模块：math 模块提供了数学函数，例如三角函数、对数函数、指数函数、常数等。
  • re 模块：re 模块提供了正则表达式处理函数，可以用于文本搜索、替换、分割等。
  • json 模块：json 模块提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON 格式中解析出 Python 对象。
  • urllib 模块：urllib 模块提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等。
• 操作系统接口：
  os模块提供了不少与操作系统相关联的函数。

建议使用 “import os” 风格而非 “from os import *”。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。

import os
os.getcwd()      # 返回当前的工作目录
'C:\\Python34'
 os.chdir('/server/accesslogs')   # 修改当前的工作目录
os.system('mkdir today')   # 执行系统命令 mkdir 
# 0

在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:

import os
 dir(os)
<returns a list of all module functions>
 help(os)
<returns an extensive manual page created from the module's docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

 import shutil
shutil.copyfile('data.db', 'archive.db')
shutil.move('/build/executables', 'installdir')

• 文件通配符
  glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

 import glob
glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

• 命令行参数
  通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 “python demo.py one two three” 后可以得到以下输出结果:

import sys
print(sys.argv)
['demo.py', 'one', 'two', 'three']

• 错误输出重定向和程序终止
  sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。
  大多脚本的定向终止都使用 “sys.exit()”。

 sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one

• 字符串正则匹配
  re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

 import re
 re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:

 'tea for too'.replace('too', 'two')
'tea for two'

• 数学
  math模块为浮点运算提供了对底层C函数库的访问:

import math
 math.cos(math.pi / 4)
0.70710678118654757
 math.log(1024, 2)
10.0

random提供了生成随机数的工具。

 import random
 random.choice(['apple', 'pear', 'banana'])
'apple'
 random.sample(range(100), 10)   # sampling without replacement
 #  [30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
 random.random()    # random float
#  0.17970987693706186
 random.randrange(6)    # random integer chosen from range(6)
#  4

• 访问互联网
  有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

 from urllib.request import urlopen
 for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     line = line.decode('utf-8')  # Decoding the binary data to text.
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print(line)

<BR>Nov. 25, 09:43:32 PM EST


#需要本地有一个在运行的邮件服务器。
import smtplib
server = smtplib.SMTP('localhost')
 server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
server.quit()

• 日期和时间
  datetime 模块为日期和时间处理同时提供了简单和复杂的方法。
  支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

import datetime

#获取当前日期和时间
current_datetime = datetime.datetime.now()
print(current_datetime)

# 获取当前日期
current_date = datetime.date.today()
print(current_date)

# 格式化日期
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)  

该模块还支持时区处理。

• 数据压缩
  以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。
• 性能度量
  有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。
  例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。
  相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

 from timeit import Timer
 Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
# 0.57535828626024577
Timer('a,b = b,a', 'a=1; b=2').timeit()
# 0.54962537085770791

• 测试模块
  开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试
  doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。
  测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。
  通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # 自动验证嵌入测试

unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        self.assertRaises(ZeroDivisionError, average, [])
        self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests

标准库文档链接
https://docs.python.org/zh-cn/3/library/index.html