python 零基础入门笔记

作用

Python是一种解释型、面向对象、动态数据类型的高级程序设计语言，在许多领域都有应用，包括Web编程，脚本编写，科学计算和人工智能等。

特点

Python 是一种：

• 解释型语言： 开发过程中没有了编译这个环节,类似于PHP和Perl语言。
• 交互式语言： 你可以在一个 Python 提示符 >>> 后直接执行代码，就像在与解释器对话一样。
• 面向对象语言: Python支持面向对象的风格或代码封装在对象的编程技术。
• 初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

Python 解释器本身几乎可以在所有的操作系统中运行。

解释器是运行以Python等解释型语言编写的脚本的程序。

1.**易于学习：**Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.**易于阅读：**Python代码的定义更清晰。
3.**易于维护：**Python的成功在于它的源代码是相当容易维护的。
4.**丰富的生态：**Python的最大的优势之一是丰富的跨平台的库，在UNIX，Linux，Windows和MacOS中都能很好的兼容。
5.**互动模式：**互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.**可移植：**基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7.**可扩展：**如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.**数据库：**Python提供所有主要的商业数据库的接口。
9.**GUI编程：**Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

python 2.x 与 python 3.x的区别

在 Python2 中，print 是一条语句，而 Python3 中作为函数存在。

print ‘Hello world’ // 这是Python2的语法

print (‘Hello world’) // 这是Python3的语法

参考的一些教程网址
c语言中文网
w3c

变量

命名规范

1. 变量名可以包括字母、数字、下划线，但是数字不能做为开头。

   2.系统关键字不能做变量名使用

   3.除了下划线之个，其它符号不能做为变量名使用 !

   4.Python的变量名是除分大小写的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hdklKkYu-1666062923497)(C:\Users\lhj\Desktop\markdown\images\162135v2czscqz7x8p88ux.png)]

数值交换

>>> x = 3 #赋值
>>> y = 5
>>> x
3
>>> y
5
>>> x, y = y, x
>>> x
5
>>> y
3

引号

分为单双引号需要成对使用

Python 对于字符串的识别是按“就近匹配”

换行符

>>> print("123\n456")  #\n表示换行
123
456

转义

>>> print("123\\n456") #\表示转义
123\n456

长字符串

>>> test = '''    #单双引号都可以，但要成双成对，前后呼应
123
456
789
'''
>>> print(test)

123
456
789

原始字符串

>>> fishc = r"""    #加r代表为原始字符串
      ___                     ___          ___          ___     
     /\  \         ___       /\  \        /\__\        /\  \    
    /::\  \       /\  \     /::\  \      /:/  /       /::\  \   
   /:/\:\  \      \:\  \   /:/\ \  \    /:/__/       /:/\:\  \  
  /::\~\:\  \     /::\__\ _\:\~\ \  \  /::\  \ ___  /:/  \:\  \ 
 /:/\:\ \:\__\ __/:/\/__//\ \:\ \ \__\/:/\:\  /\__\/:/__/ \:\__\
 \/__\:\ \/__//\/:/  /   \:\ \:\ \/__/\/__\:\/:/  /\:\  \  \/__/
      \:\__\  \::/__/     \:\ \:\__\       \::/  /  \:\  \      
       \/__/   \:\__\      \:\/:/  /       /:/  /    \:\  \     
                \/__/       \::/  /       /:/  /      \:\__\    
                             \/__/        \/__/        \/__/
                             """
>>> print(fishc)

      ___                     ___          ___          ___     
     /\  \         ___       /\  \        /\__\        /\  \    
    /::\  \       /\  \     /::\  \      /:/  /       /::\  \   
   /:/\:\  \      \:\  \   /:/\ \  \    /:/__/       /:/\:\  \  
  /::\~\:\  \     /::\__\ _\:\~\ \  \  /::\  \ ___  /:/  \:\  \ 
 /:/\:\ \:\__\ __/:/\/__//\ \:\ \ \__\/:/\:\  /\__\/:/__/ \:\__\
 \/__\:\ \/__//\/:/  /   \:\ \:\ \/__/\/__\:\/:/  /\:\  \  \/__/
      \:\__\  \::/__/     \:\ \:\__\       \::/  /  \:\  \      
       \/__/   \:\__\      \:\/:/  /       /:/  /    \:\  \     
                \/__/       \::/  /       /:/  /      \:\__\    
                             \/__/        \/__/        \/__/
                             
print(fishc)  #不加r会导致转义乱码

      ___                     ___          ___          ___     
     /\  \         ___       /\  \        /\__\        /\  \    
    /::\  \       /\  \     /::\  \      /:/  /       /::\  \   
   /:/\:\  \      \:\  \   /:/\ \  \    /:/__/       /:/\:\  \  
  /::\~\:\  \     /::\__\ _\:\~\ \  \  /::\  \ ___  /:/  \:\  \ 
 /:/\:\ \:\__\ __/:/\/__//\ \:\ \ \__\/:/\:\  /\__\/:/__/ \:\__ \/__\:\ \/__//\/:/  /   \:\ \:\ \/__/\/__\:\/:/  /\:\  \  \/__/
      \:\__\  \::/__/     \:\ \:\__\       \::/  /  \:\  \      
       \/__/   \:\__\      \:\/:/  /       /:/  /    \:\  \     
                \/__/       \::/  /       /:/  /      \:\__\    
                             \/__/        \/__/        \/__/

帮助文档

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

print函数

函数概述：

print() 函数用于打印输出一个对象。

参数解析：

参数	含义
objects	指定待输出的对象，多个对象之间使用英文逗号（,）进行分隔
sep	指定输出多个对象之间的分隔符，默认是空格（' '）
end	指定最后的结束符，默认是换行符（'\n'）
file	指定要写入的文件对象，默认是标准输出流（sys.stdout）
flush	指定是否强制刷新输出流，默认是不刷新（False）

注：如果指定 sep, end, file 和 flush 参数，需要使用关键字参数（即通过指定参数名来赋值）。

格式化输出

占位符	说明
%s	字符串(采用str()的显示)
%r	字符串(采用repr()的显示)
%c	单个字符
%b	二进制整数
%d	十进制整数
%i	十进制整数
%o	八进制整数
%x	十六进制整数
%e	指数 (基底写为e)
%E	指数 (基底写为E)
%f	浮点数
%F	浮点数，与上相同
%g	指数(e)或浮点数 (根据显示长度)
%G	指数(E)或浮点数 (根据显示长度)

format

print("lll is {sex}, {year} old".format(sex="boy", year=20))

>>lll is boy, 20 old

数学运算

Python执行乘法和除法，用星号 * 表示乘法和正斜杠 / 来表示除法。

有括号先执行括号内操作。

print(2 * (3 + 4))     #结果为 14
print(10 / 2) 		   #结果为 5.0

使用除法结果会变成浮点数（有小数点），我们将在后面的课程中介绍更多有浮点数的知识。

print((-7 + 2) * (-4))  #结果为20，减号放在数字前表示负数。

print(5 / 0)

Traceback (most recent call last):
  File "..\Playground\", line 1, in <module>
    \ufeffprint(5 / 0)
ZeroDivisionError: division by zero  #最后一行代表错误类型

函数

random – 生成伪随机数

函数概要：

随机数状态的相关函数

random.seed(a=None, version=2) – 初始化随机数生成器

参数	含义
a	1. 如果省略该参数或者将其值设置为 None（默认），将使用当前系统时间作为随机数种子（如果操作系统提供了随机性来源，则用它来代替系统时间） 2. 如果参数 a 为整数，则直接被用作随机数种子 3. 该参数的值也可以是字符串、字节、字节数组等
version	1. 如果 version=2（默认），字符串、字节或字节数组对象的每一个位都将比转换成整数使用 2. version=1，用于从旧版本的 python 中复制随机序列，字符串和字节算法生成更窄的种子范围

random.getstate()

– 返回捕获当前生成器内部状态的对象。
– 返回的对象可以传递给下面的 setstate() 函数，用于恢复状态。

random.setstate(state)

– 设置生成器的内部状态
– 传入一个先前利用 getstate() 函数获得的状态对象，使得生成器恢复到这个状态。
– 小甲鱼：getstate() 和 setstate() 两个函数搭配使用，可以重现之前获取到的随机值。

random.getrandbits(k)

– 返回一个不大于 k 位的 Python 整数（十进制），比如 k=10，则返回的结果是在 0 ~ 2^10 之间的整数。

整数相关的随机函数

random.randrange(stop)

random.randrange(start, stop[, step])

– 从 range(start, stop, step) 中随机选择一个元素返回。
– 功能相当于 choice(range(start, stop, step))，但它不会创建一个 range 对象。
– 传递的位置参数应该与 range() 模式匹配。
– 不应该使用关键字参数，因为函数可能以未定义的方式使用它们。

参数	含义
start	1. 指定起始值 2. 如果省略该参数，其默认值是 0
stop	指定结束值
step	1. 指定步长，其值可以是正数也可以是负数 2. 如果省略该参数，其默认值是 1 3. 如果该参数被设置为 0，Python 将抛出 ValueError 异常

• 随机整数

random.randint(a, b)

– 返回一个随机整数 N，返回是：a <= N <= b

序列相关的随机函数

random.choice(seq)

– 从 seq 参数指定的序列中返回一个随机元素。
– 如果 seq 是空序列，Python 将抛出 IndexError 异常。

*random.choices(population, weights=None, , cum_weights=None, k=1)

– 从 population 参数指定的序列中随机抽取 k 个元素并返回。
– weights 参数是指定相对权重列表，cum_weights 参数是指定累积权重列表（相对权重 [10，5，30，5] 等同于累积权重 [10，15，45，50]），两个参数不能同时存在（注：如果同时存在，Python 将抛出 TypeError 异常）。
– 如果没有指定 weights 相对权重和 cum_weights 累积权重，那么每个元素被选中的概率是相同的。
– 如果指定任一权重参数，那么其长度必须与 population 参数指定的序列长度一致。

random.shuffle(x[, random])

– 原地打乱 x 参数指定的（可变）序列。
– 可选参数是一个 0 参数函数，其返回一个范围在 [0.0, 1.0) 之间的随机浮点数，默认是使用 random() 函数。
– 如果要打乱一个不可变序列（比如字符串），可以使用 sample(x, k=len(x)) 函数实现，它会生成一个元素打乱后的列表。

random.sample(population, k)

– 从 population 参数指定的序列或集合中，随机抽取 k 个不重复的元素构成新序列并返回。
– 该函数返回的是一个新的随机序列，不会破坏原序列，常用于不重复的随机抽样。
– 如果 k 参数的值大于 population 参数指定的序列或集合的元素个数，Python 抛出 ValueError 异常。
– 如果要从一个整数区间中随机抽取一定数量的整数，推荐使用 range() 对象作为参数（比如 sample(range(1, 34), k=6) 就是从 1 到 33 之间随机抽取不重复的 6 个数字），这样实现的效率非常高并且节省内存空间。

实值分布相关的随机函数

以下函数生成特定的随机实数分布。函数参数是根据分布方程式中的相应变量命名的，这在普通数学操作中经常用到；这些方程式大多数都可以在统计文本中被找到。

random.random()

– 返回一个范围在 [0.0, 1.0) 之间的随机浮点数。

random.uniform(a, b)

– 返回一个随机的浮点数 N。
– 如果 a <= b，则 a <= N <= b。
– 如果 b < a，则 b <= N <= a。

random.triangular(low, high, mode)

– 返回一个三角分布的随机浮点数 N，其中 low <= N <= high。
– 众数值通过 mode 参数指定。
– low 和 high 参数的默认值是 0 和 1，mode 参数的默认值是边界之间的中心点。

random.betavariate(alpha, beta)

– 返回一个 Beta 分布的随机浮点数。
– 参数 alpha 和 beta 都应该大于 0。
– 返回值的返回在 0 到 1 之间。

random.expovariate(lambd)

– 指数分布。
– lambd 参数的值是 1/期望值 的结果，所以是一个非 0 值。
– 如果 lambd 参数的值为正，则返回值的范围为 0 到正无穷大；如果lambd 参数的值为负，则返回值的范围为 0 到负无穷大。

random.gammavariate(alpha, beta)

– Gamma 分布（不是 Gamma 函数！）。
– 条件参数 alpha > 0，且 beta > 0。
– 概率分布函数如下：

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

random.choice

从非空序列 seq 返回一个随机元素。如果 seq 为空，则引发 IndexError

>>> import random
>>> random.choice("luohj123")
'u'
>>> random.choice("luohj123")
'2'

random.gauss(mu, sigma)

– 高斯分布。
– mu 参数指定的是均值，sigma 参数指定的是标准差。
– 该函数要比下面的 normalvariate() 函数（正态分布函数）稍微快一些。

random.lognormvariate(mu, sigma)

– 对数正态分布。
– mu 参数指定的是均值，sigma 参数指定的是标准差。
– mu 参数可以是任意值，但 sigma 参数的值必须大于 0。

random.normalvariate(mu, sigma)

– 正态分布。
– mu 参数指定的是均值，sigma 参数指定的是标准差。

random.vonmisesvariate(mu, kappa)

– 卡方分布。
– mu 参数指定的是平均角度，以 0 到 2pi 之间的弧度表示。
– kappa 参数指定的是自由度，必须大于或者等于 0。
– 如果 kappa 参数的值等于 0，该分布在 0 到 2pi 范围内减少到一个均匀的随机角。

random.paretovariate(alpha)

– 帕累托分布（小甲鱼：20% 的人口拥有 80% 的财产就这个）。
– alpha 参数指定的是形状参数。

random.weibullvariate(alpha, beta)

– Weibull 分布。
– alpha 参数指定的是比例参数。
– beta 参数指定的是形状参数。

替代生成器

class random.SystemRandom([seed])

– 使用 os.urandom() 函数的类，利用操作系统提供的源来生成随机数。
– 该类并不是所有操作系统都适用。
– 该类不依赖于软件状态，并且序列不可重现。所以，seed() 方法没有效果而被忽略，getstate() 和 setstate() 方法如果被调用则抛出 NotImplementedError 异常。

关于 “再现” 的备注

有时候，能够再现伪随机数生成器给出的序列是有用的。

通过重新使用相同的种子值（只要多个线程没有运行），相同的伪随机数序列就应该可以被生成。

随着 Python 版本的迭代，随机模块的算法和种子设定函数有可能会发生改变，但以下两个方面保证不会有变动：

• 如果添加了新的种子生成方法，则将提供向后兼容的方案
• 当提供的种子一样时，random() 方法将生成一样的伪随机数

基本用法

>>> random()                             # 返回一个浮点数 x:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # 返回一个浮点数 x：2.5 <= x < 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # 指数分布，平均到达时间为 5 秒
5.148957571865031

>>> randrange(10)                        # 从 0 ~ 9（包含）中随机取出一个整数
7

>>> randrange(0, 101, 2)                 # 从 0 ~ 100（包含）中随机取出一个偶数
26

>>> choice(['win', 'lose', 'draw'])      # 从序列中随机取出一个元素
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # 打乱一个列表
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # 在给定的序列中生成 4 个随机数
[40, 10, 50, 30]

decimal – 实例化对象

基本用法

• 精确计算浮点数

>>> import decimal
>>> a = decimal.Decimal('0.1')
>>> b = decimal.Decimal('0.2')
>>> print(a + b)
0.3

Fraction

• 分数约分

>>> from fractions import Fraction
>>>print(Fraction(1708227363155544,4636617128565048))
7/19

range

range() 会帮你生成一个数字序列

• range(stop) - 将生成一个从 0 开始，到 stop（不包含）的整数数列
• range(start, stop) - 将生成一个从 start 开始，到 stop（不包含）的整数数列
• range(start, stop, step) - 将生成一个从 start 开始，到 stop（不包含）结束，步进跨度为 step 的整数数列

数字类型

整数

python整数长度不受限制

整数除法会得到小数也就是浮点数

>>> 3 / 2
1.5
>>> 6 / 3
2.0

浮点数

python利用IEEE754标准来存储浮点数

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.00000006   6乘10的负8次方
6e-08           #E记法也就是科学计数法

复数

>>> x = 1 + 2j   
>>> x.real   #获取实部数值
1.0 
>>> x.imag   #获取虚部数值
2.0

数字运算

• / 除法

  >>> 4 / 3           #不论结果都会返回浮点数，且除数不能为0
  1.3333333333333333
  >>> 4 / 2
  2.0
  >>> 4 / 0
  Traceback (most recent call last):
    File "<pyshell#7>", line 1, in <module>
      4 / 0
  ZeroDivisionError: division by zero
  

• 地板除 //

  >>> 3 // 2    #返回整数
  1
  >>> -3 // 2
  -2
  >>> 8 // 2
  4
  >>> 8/2
  4.0
  >>> 8/3
  2.6666666666666665
  

• x除y的余数

  >>> 3 % 2
  1
  >>> 6 % 2
  0
  

• 绝对值

  >>> x = -1
  >>> abs(x)
  1
  >>> x = -3.14
  >>> abs(x)
  3.14
  

• 转换为整数

  >>> x = 9.99
  >>> int(x)
  9
  

• 幂运算取余

>>> pow(3,4,5)
1
>>> 3 ** 4
81
>>> 81 % 5
1

布尔类型bool

>>> bool("false")
True
>>> bool(100)
True
>>> bool(" ")
True
>>> bool("")
False
>>> bool(0)
False
>>> bool(0.1)
True
>>> 1 == True
True
>>> 0 == False
True

逻辑运算符or，and，not

在 Python 中，所有的对象都可以进行真值检测

>>> 3 < 4 and 4 < 5
True
>>> 3 < 4 and 3 > 5
False
>>> 3 < 4 or 3 > 5
True
>>> 3 > 4 and 3 > 5
False
>>> not True
False
>>> not False
True
>>> not 100
False
>>> not 0
True
>>> "abc" and "ABC"
'ABC'
>>> "a" or "b"
'a'
>>> "a" or "1"
'a'

短路逻辑和运算符优先级

• 核心思想：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值。

优先级	运算符	描述
1	lambda	Lambda 表达式
2	if - else	条件表达式
3	or	布尔“或”
4	and	布尔“与”
5	not x	布尔“非”
6	in, not in, is, is not, <, <=,>, >=, !=, ==	成员测试，同一性测试，比较
7	|	按位或
8	^	按位异或
9	&	按位与
10	<<, >>	移位
11	+, -	加法，减法
12	*, @, /, //, %	乘法，矩阵乘法，除法，地板除，取余数
13	+x，-x, ~x	正号，负号，按位非（翻转）
14	**	指数
15	await x	Await 表达式
16	x[index], x[index:index],x(arguments…), x.attribute	下标，切片，函数调用，属性引用
17	(expressions…), [expressions…],{key: value…}, {expressions…}	绑定或元组显示，列表显示，字典显示，集合显示

数字越大优先级越高

分支与循环

• 判断奇偶性

num = int(input('请输入一个整数：'))

if num % 2 == 0:
    print("%d是一个偶数" % (num))
else:
    print(num,'是一个奇数' ,sep='')   
    
请输入一个整数：11
11 是一个奇数

请输入一个整数：11
11是一个奇数
#默认情况下，print() 函数输出的多个对象之间是使用空格分隔，但我们可以使用 sep='' 来 “避免” 这种情况发生

条件表达式

>>> a = 5
>>> b = 6
>>> print(a<b) if a < b else print(a>b)
True

条件成立执行前面的，反之执行后面的

循环

while循环（条件为真开始循环）

例子：计算1-1000的和

i = 1
sum = 0

while i <= 1000:
    sum += i
    i += 1
print(sum)

500500

break 跳出循环

i = 1
sum = 0

while i <= 1000:
    sum += i
    i += 1
    if i == 500:
        break

print(sum)

124750

continue 跳出本轮循环

i = 0


while i <= 10:
    i += 1
    if i % 2 == 0:
            continue

    print(i)

#跳过i为偶数时的循环
1
3
5
7
9
11

break和continue只作用于一层循环体

循环嵌套

九九乘法表

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(i, '*', j, '=', i * j, end=' ')
        j += 1
    print()
    i += 1

1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4 
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 

面向对象

面向对象——行为化（概念相对抽象，可结合下面的例子理解）

• 面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成类（类实例化后才是对象），创建了对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为

  • 所有数据皆是一个对象，字符串、整数、浮点、列表、元组、字典、函数、类、类实例、模块、文件等

列表

定义

• *列表（List）*是一种有序和可更改的集合。允许重复的成员。

列表是一种可以改变内容的数据类型，由一系列元素组成，列表可由整数，浮点数，字符串，或是其他列表，字典等组成。

例子：生成字符串

string = "1425najdn"  # 生成字符串

list1 =list(string)	  # 转换成列表

for i in list1:      # 遍历列表
  print(i)


1
4
2
5
n
a
j
d
n

例子：字符串反转输出

string = "cdbd"  #随意定义一个字符串

list1 = list(string)  #转化为列表

num = ' '
i = len(list1) - 1   #lie'biao

while i >= 0:
    num = num + list1[i]
    i -= 1

print(num)

例子：给定列表，输出元素值索引

#定义为空列表
list1 = []
string = input("请录入一个整数（输入stop结束) :")

while string != "stop":
    #将每一个输入的值加入列表
    list1.append(string)
    string = input("请录入一个整数（输入stop结束) :")
else:
    #给列表排序
    list1.sort()
    #取得target值
    target = int(input("请输入目标整数："))
    #循环判断
    i = 0
    while i <= len(list1) - 1:
        a = 0
        while a <= i:
            if int(list1[i]) + int(list1[a]) == target:
                if i <= a:
                    print("[",i, a,"]")
                else:
                    print("[",a, i,"]")
            a += 1
        i += 1

访问列表中的项目

#stack = []   #定义空列表

stack = ["apple","desk","pen",] # 用中括号定义一个列表，最后一个逗号可加可不加

print(stack[2])  #列表中的元素索引从0开始，所以这里的2取的是第3个元素

>>> pen

print(stack[0])

>>> apple

print(stack[-1]) #负数代表从末尾取

>>> pen

print(stack[-2])

>>> desk

#超出索引长度会抛出异常 

切片

stack = ["1", "3", "4", "5", "7", "abcde"]

print(stack[0:8:2])          #从第一个元素开始，到最后一个元素结束（此时列表含有元素小于8，所以代表最后一个，步进值为2

>>> ['1', '4', '7']

stack = ["1", "3", "4", "5", "7", "abcde"]

print(stack[::2])             #代表从第一个到最后一个元素，每隔两个打印一次

>>> ['1', '4', '7'] 

stack = ["1", "3", "4", "5", "7", "abcde"]

print(stack[::-1])				 #倒序

>>> ['abcde', '7', '5', '4', '3', '1']        

删除或增加列表中的元素

stack = ["apple","desk","pen"]   #定义初始列表

#增加

1.append() 方法: 添加元素到列表的末尾  #适合添加单个对象 多个对象使用extend

stack.append("orange")
print(stack[:])

>>> ['apple', 'desk', 'pen', 'orange'] # 新元素被添加到了列表的末尾

2.insert() 方法：添加元素到列表的指定索引位置

stack.insert(2,"banana")
print(stack[:])

>>> ['apple', 'desk', 'banana', 'pen'] #添加元素到索引为2的位置

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

list1.insert(len(list1), 6)  #将指定元素插到列表最后

print(list1)
2.2将列表2元素插入到列表1，索引2的位置

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

for i in list2:
    list1.insert(-2, i)      #后面循环的会不断代替索引2的位置，所以需要倒序插入

# list1.insert(2, list2)     #这是直接插入整个列表

print(list1)

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]

3.索引赋值    #改值

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

list1[len(list1):] = [6]    #设置索引为6

print(list1)

3.2利用值来改

heroes = ["abc", "祖国人", "jack", "lucy"]

heroes[heroes.index("jack")] = "tom"  #取得值的索引，然后利用索引修改 #如果有多个相同的值默认

print(heroes)

#删除

1.remove() 方法： 删除指定的元素

stack.remove("desk")
print(stack[:])

>>> ['apple', 'pen']

2.pop() 方法： 删除指定的索引（如果未指定索引，则删除最后一项）

stack.pop()
print(stack[:])

>>> ["apple","desk"]

stack.pop(1)
print(stack[:])

>>> ['apple', 'pen']

3.del 关键字: 删除指定的索引

del stack[0]
print(stack[:])

>>> ['desk', 'pen']

del stack        #直接删除整个列表
print(stack[:])

NameError: name 'stack' is not defined

4.clear 关键字：清空列表

stack.clear()
print(stack[:])

复制列表

1.浅复制 类似快捷方式

stack = ["apple","desk","pen"]

oragcle = stack
print(oragcle[:])

>>> ['apple', 'desk', 'pen']

oragcle = stack
stack.pop(0)         #删除stack列表的第一个元素
print(oragcle[:])   

>>> ['desk', 'pen']  #对原始列表的更改映射到了新字符串

2.深复制 方法 copy()

stack = ["apple","desk","pen"]

oragcle = stack.copy()

stack.pop(0)
print(stack[:])
print(oragcle[:])

>>> ['desk', 'pen']      
    ['apple', 'desk', 'pen'] #对原始列表的更改不影响新字符串

3.深复制 方法 list()

stack = ["apple","desk","pen"]

oragcle = list(stack)

stack.pop(0)
print(stack[:])
print(oragcle[:])

>>> ['desk', 'pen']      
    ['apple', 'desk', 'pen']

合并列表

1.运算符合并

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list3 = list1 + list2   #利用运算符+
print(list3)

>>> ['a', 'b', 'c', 1, 2, 3]

2.**append()**方法追加

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:     
  list1.append(x)   #遍历列表然后循环追加

print(list1)

>>> ['a', 'b', 'c', 1, 2, 3]

3.extend() 方法

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]


list1.extend(list2)
print(list1)

>>> ['a', 'b', 'c', 1, 2, 3]

列表内建方法

方法	含义
s.append(x)	将 x 元素添加到 s 列表的末尾，相当于 s[len(s):] = [x]
s.extend(iterable)	将可迭代对象中的每个元素依次添加到 s 列表的末尾，相当于 s[len(s):] = iterable
s.insert(i, x)	将 x 元素插入到 s 列表中的 i 位置（其它元素依次往后递推）。所以，s.insert(0, x) 是将 x 元素插入到 s 列表的开头；s.insert(len(s), x) 则是将 x 元素插入到 s 列表的末尾，等同于 s.append(x)
s.remove(x)	删除 s 列表中第一个 x 元素；如果列表中不存在 x 元素，则抛出 ValueError 异常
s.pop(i)	删除 s 列表中第 i 个元素，并将其返回；如果没有指定 i 参数，s.pop() 将删除最后一个元素并返回
s.clear()	删除 s 列表中的所有元素，相当于 del a[:]
s.index(x[, start[, end]])	返回 x 元素位于 s 列表的索引值（start 和 end 可选，指定开始和结束位置，不过返回的索引值仍然是以序列开始位置计算的）；如果找不到，则返回 ValueError 异常
s.count(x)	返回 x 元素在 s 列表中出现的次数
s.sort(key=None, reverse=False)	对列表中的元素进行原地排序（key 参数指定一个用于比较的函数；reverse 参数用于指定排序结果是否反转）
s.reverse()	原地反转列表中的元素（第一个与最后一个互换，第二个与倒数第二个互换，第三个与倒数第三个互换，…）
s.copy()	返回 s 列表的一个浅拷贝，相当于 s[:]

元组

定义

• *元组（Tuple）*是一种有序且不可更改的集合。允许重复的成员。

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。

生成元组

1.直接定义

nametuple = ("jack","tom","tony","alice")

print(type(nametuple))

>>> <class 'tuple'>

2.构造函数生成

thistuple = tuple(("apple", "banana", "cherry")) # 请注意双括号
print(thistuple)

>>> ('apple', 'banana', 'cherry')

访问元组

有序指索引，与列表相同，可以通过索引访问相应值

更改元组

不可更改只是不能直接更改，但是可以间接更改

但是我们可以将元组转换为列表，更改列表，然后将列表转换回元组。

nametuple = ("jack","tom","tony","alice") #定义元组

namelist = list(nametuple)   #转化为列表
namelist[1] = 123            #更改元素
nametuple = tuple(namelist)  #转回元组

print(type(nametuple))
print(nametuple)

>>> <class 'tuple'>
('jack', 123, 'tony', 'alice')

遍历元组

nametuple = ("jack","tom","tony","alice")

for i in nametuple:
    print(i)
    
>>> jack
    tom
	tony
	alice

检查元素是否存在

nametuple = ("jack","tom","tony","alice")

if "jack" in nametuple:
    print('yes')

>>> yes

元组长度

**len()**方法

nametuple = ("jack","tom","tony","alice")

print(len(nametuple))

>>> 4

创建有一个项目的元组

onetuple = (2)  #后面不加逗号，被识别成整数

print(type(onetuple))

>>> <class 'int'>

onetuple = ('a',)  #如果是字符串，则需要使用引号括起来

print(type(onetuple))

>>> <class 'tuple'>

删除元组

元组不可更改，所以也无法直接删除，但是可以删除元组本身

1.del 关键字 删除元组

nametuple = ("jack","tom","tony","alice")

del nametuple

print(nametuple)

>>> NameError: name 'nametuple' is not defined

合并元组

运算符直接合并元组

onetuple = (1,2,3,)

twotuple = ('a','b','c',)

atuple = onetuple + twotuple

print(atuple)

>>> (1, 2, 3, 'a', 'b', 'c')

元组内建方法

方法	描述
count()	返回元组中指定值出现的次数。
index()	在元组中搜索指定的值并返回它被找到的位置。

集合

定义

• *集合（Set）*是一个无序和无索引的集合。没有重复的成员。

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

创建集合

set_one = {'123','3','abc','jack'}

print(type(set_one))

>>> <class 'set'>

访问集合中元素

集合是无序的所以没有索引

可以通过for循环来遍历

set_one = {'123','3','abc','jack'}

for i in set_one:
    print(i)
    
>>> abc
    jack
    3
    123

查询集合指定元素是否存在

set_one = {'123','3','abc','jack'}

print("123" in set_one)

>>> True

添加元素

1.单个元素添加

set_one = {'123','3','abc','jack'}


set_one.add("tom")

print(set_one)

>>> {'tom', '3', '123', 'abc', 'jack'}

2.多个元素添加

set_one = {'123','3','abc','jack'}

set_one.update(["back","enter"])

print(set_one)

>>> {'abc', '123', 'back', '3', 'enter', 'jack'}

获取 集合长度

**len()**方法

set_one = {'123','3','abc','jack'}

set_one.update(["back","enter"])

print(len(set_one))

>>> 6

删除集合元素

remove() 方法 //如果要删除的元素不存在，则 remove() 将引发错误

set_one = {'123','3','abc','jack'}

set_one.remove('123')

print(set_one)

>>> {'3', 'jack', 'abc'}

discard() 方法 //删除的元素不存在，也不会引发错误

set_one = {'123','3','abc','jack'}

set_one.discard('123')
set_one.discard("397")

print(set_one)

>>> {'jack', 'abc', '3'}

还可以使用 pop() 方法删除集合最后一个元素，但是你不知道被删除的是什么元素

删除集合

使用关键字del clear与列表一样

合并集合

1. union() 方法 //返回包含两个集合中所有项目的新集合

set_one = {'123','3','abc','jack'}
set_two = {'back','shift'}

new_set = set_one.union(set_two)
print(new_set)

>>> {'jack', 'shift', 'back', 'abc', '3', '123'}

2.update() 方法 //将一个集合所有元素插入另一个集合

set_one = {'123','3','abc','jack'}
set_two = {'back','shift'}

set_one.update(set_two)
print(set_one)

>>> {'123', 'back', 'shift', 'jack', '3', 'abc'}

上面2种方法能自动排除重复项

集合内建方法、

方法	描述
add()	向集合添加元素。
clear()	删除集合中的所有元素。
copy()	返回集合的副本。
difference()	返回包含两个或更多集合之间差异的集合。
difference_update()	删除此集合中也包含在另一个指定集合中的项目。
discard()	删除指定项目。
intersection()	返回为两个其他集合的交集的集合。
intersection_update()	删除此集合中不存在于其他指定集合中的项目。
isdisjoint()	返回两个集合是否有交集。
issubset()	返回另一个集合是否包含此集合。
issuperset()	返回此集合是否包含另一个集合。
pop()	从集合中删除一个元素。
remove()	删除指定元素。
symmetric_difference()	返回具有两组集合的对称差集的集合。
symmetric_difference_update()	插入此集合和另一个集合的对称差集。
union()	返回包含集合并集的集合。
update()	用此集合和其他集合的并集来更新集合。

字典

定义

• *字典（Dictionary）*是一个无序，可变和有索引的集合。没有重复的成员

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

创建字典

直接定义

people_dict = {"name": "zbc","old": "20","sex": "boy"}

print(type(people_dict))

>>> <class 'dict'>

利用函数构造

new_dict = dict(name="zbc",old="28")

print(type(new_dict))

print(new_dict)


>>> <class 'dict'>
	{'name': 'zbc', 'old': '28'}

访问字典内元素

1.根据键名获取

people_dict = {"name": "zbc","old": "20","sex": "boy"}

x = people_dict["name"]
print(x)

>>> zbc

2.get() 方法获取

people_dict = {"name": "zbc","old": "20","sex": "boy"}

x = people_dict.get("name")
print(x)

>>> zbc

更改元素

people_dict = {"name": "zbc","old": "20","sex": "boy"}

people_dict["name"] = "jbc" #修改name键值为jbc
print(people_dict)

>>> {'name': 'jbc', 'old': '20', 'sex': 'boy'}

遍历字典

1.打印字典所有键

people_dict = {"name": "zbc","old": "20","sex": "boy"}

for i in people_dict:
    print(i)

>>> name
    old
    sex

2.打印字典所有值

people_dict = {"name": "zbc","old": "20","sex": "boy"}

for i in people_dict:
    print(people_dict[i])
    
>>> zbc
    20
    boy

3.使用 values() 函数打印字典所有值

people_dict = {"name": "zbc","old": "20","sex": "boy"}

for i in people_dict.values():
    print(i)
    
>>> zbc
    20
    boy

4.使用items()函数遍历键和值

people_dict = {"name": "zbc","old": "20","sex": "boy"}

for i in people_dict.items():
    print(i)

>>> ('name', 'zbc')
    ('old', '20')
    ('sex', 'boy')

检查键是否存在字典

people_dict = {"name": "zbc","old": "20","sex": "boy"}

if "name" in people_dict:
    print('yes')

>>> yes

字典长度

len() 方法确定字典有多少个键值对

people_dict = {"name": "zbc","old": "20","sex": "boy"}

print(len(people_dict))

添加新元素

people_dict = {"name": "zbc","old": "20","sex": "boy"}

people_dict["color"] = "red"
print(people_dict)

>>> {'name': 'zbc', 'old': '20', 'sex': 'boy', 'color': 'red'}

删除元素

1.pop() 方法删除具有指定键名的元素：

people_dict = {"name": "zbc","old": "20","sex": "boy"}

people_dict.pop("sex")
print(people_dict)

>>> {'name': 'zbc', 'old': '20'}

2**.popitem()**方法删除最后插入的元素（在 3.7 之前的版本中，删除随机元素）

people_dict = {"name": "zbc","old": "20","sex": "boy"}

people_dict.popitem()
print(people_dict)

>>> {'name': 'zbc', 'old': '20'}

3.del 关键字删除具有指定键名的元素

people_dict = {"name": "zbc","old": "20","sex": "boy"}

del people_dict["name"]
print(people_dict)

>>> {'old': '20', 'sex': 'boy'}

4.del 删除字典

people_dict = {"name": "zbc","old": "20","sex": "boy"}

del people_dict
print(people_dict)

>>> NameError: name 'people_dict' is not defined

字典复制

与列表一样

嵌套字典

1.包含

people_dict = {"name": "zbc","old": "20","sex": "boy"}
people_dict2 = {"name": "qwe","old": "19","sex": "girl"}

people_dict3 = {"people_dict": people_dict,"people_dict2": people_dict2}
print(people_dict3)

>>> {'people_dict': {'name': 'zbc', 'old': '20', 'sex': 'boy'}, 'people_dict2': {'name': 'qwe', 'old': '19', 'sex': 'girl'}}

2.直接定义

people_dict3 = { "people_dict" : {"name": "zbc","old": "20","sex": "boy"},"people_dict2" : {"name": "qwe","old": "19","sex": "girl"} }
print(people_dict3)

>>> {'people_dict': {'name': 'zbc', 'old': '20', 'sex': 'boy'}, 'people_dict2': {'name': 'qwe', 'old': '19', 'sex': 'girl'}}

3.利用函数构造

new_dict = dict(name="zbc",old="28")

print(type(new_dict))

print(new_dict)


>>> <class 'dict'>
	{'name': 'zbc', 'old': '28'}

字典内建方法

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
fromkeys()	返回拥有指定键和值的字典，fromkeys() 方法的第一个参数传入的是一个可迭代对象，将其中的每个元素作为键，方法的第二个参数作为值（如果没有指定该参数，则默认初始化为 None
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除拥有指定键的元素
popitem()	删除最后插入的键值对
setdefault()	返回指定键的值。如果该键不存在，则插入具有指定值的键。
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表

自定义函数

函数是一种仅在调用时运行的代码块。

您可以将数据（称为参数）传递到函数中。

函数可以把数据作为结果返回。

好处

• 可以最大程度地实现代码重用，减少冗余的代码
• 可以将不同功能的代码段进行封装、分解，从而降低结构的复杂度，提高代码的可读性

定义及调用函数

• 在 Python 中，使用 def 关键字定义函数

def function():             #定义函数名
    print("hello wolrd")    #函数内容

function()      #调用/使用函数

• 添加说明文档

def function():
    """说明文档        #添加函数下面的第一块3引号包裹的语句为说明文档
    此函数打印hello world
    """
    print("hello wolrd")


function()    

help(function)  查看说明文档
>>>
hello wolrd
Help on function function in module __main__:

function()
    说明文档
    此函数打印hello world
(END)

传参

参数增加了函数的灵活性

从调用角度来看，参数可以细分为：形式参数（parameter）和实际参数（argument）。

其中，形式参数是函数定义的时候写的参数名字（比如下面例子中的 fname ）；实际参数是在调用函数的时候传递进去的值

def function(fname):     #定义参数  形参
    print("hello",fname)

name = ["jack","tom"]   #循环参数   实参

for fname in name:
    function(fname)
    
>>> hello jack
	hello tom

默认参数

如果我们调用了不带参数的函数，则使用默认值

def function(fname="zbc"):
    print("hello",fname)
function()

>>> hello zbc

列表传参

传递给函数的参数可以是任何数据类型（字符串、数字、列表、字典等）

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

>>> apple
    banana
    cherry

函数返回值

利用return语句获取函数返回值

def my_function(x):
  return x * x

print(my_function(3))
print(my_function(5))

>>> 9
	25

执行到return语句之后立刻返回结果并且不会再执行下面的语句 ，如果一个函数没有通过 return 语句返回，它也会自己在执行完函数体中的语句之后，悄悄地返回一个 None 值

如果一个return语句有多个返回值，将会打包成元组的方式返回

关键字传参

以键值对形式 key = value,关键字传参又称为kwargs

def my_name(name1,name2,name3):
    print(name1,"and",name3,"is friend")


my_name(name1= "jack",name3 = "tony")

>>> jack and tony is friend

TypeError: my_name() missing 1 required positional argument: 'name2'  //即使某个参数用不到也需要传参，不然会报错

任意参数传参

如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。

函数将接收一个参数元组，并可以相应地访问各项

• 收集参数

def test(*args, a, b):
    print(type(args))
    print(a, b)


test(1, 2, 3, a=4, b=5)

>>> 
<class 'tuple'>
4 5

def my_many(*count):
    print("number is ", count[2])  #加索引


my_many(1,2,3)

>>> number is  3

def my_many(*count):
    print("number is ", count)    #不加索引


my_many(1,2,3)

>>> number is (1, 2, 3)

• 收集字典参数

<class 'dict'>
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

• 混合传参

def myfunc(a, *b, **c):
    print(a, b, c)


myfunc(1, 2, 3, 4, x=5, y=6)
>>>
1 (2, 3, 4) {'x': 5, 'y': 6}

• 传参限制

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        关键字或位置参数   |
        |                                - *后面仅限关键字参数
         -- /前面仅限位置参数传参

解包参数

形参使用叫打包，实参使用叫解包

args = (1, 2, 3, 4,)


def myfunc(a, b, c, d):
    print(a, b, c, d)
myfunc(*args)

>>> 1 2 3 4

pass

pass用作函数占位语句，未写完时定义可以避免错误

def function():     //不影响其他函数运行
    pass  

递归

函数能调用自身

##一步步计算10以内所有数字的和
def tri_recursion(k):
  if(k>0):
    result = k+tri_recursion(k-1)
    print(result)
  else:
    result = 0
  return result

tri_recursion(10)

>>> 1
    3
    6
    10
    15
    21
    28
    36
    45
    55

Lambda

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。

• 在lambda后面直接跟变量
• 变量后面是冒号
• 冒号后面是表达式，表达式计算结果就是本函数的返回值

x = lambda a : a + 10
y = lambda y : y * y

print(x(5))

print(y(5))

>>> 15
	25

#多个参数

count = lambda a, b, c : a * b + c

print(count(3, 6, 8))

>>> 26

匿名函数

lambda 用作另一个函数内的匿名函数

#使给定的数字翻倍
def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

>>> 22

在同一程序中使用相同的定义生成2个函数

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(5)

print(mydoubler(11))
print(mytripler(20))

>>> 22
	100

类和对象

Python 是一种面向对象的编程语言。

Python 中的几乎所有东西都是对象，拥有属性和方法。

类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”。

类是指具有相同属性的对象，对象是类的实例化

创建类

类由class 关键字创建

class my_class:
  x = 5

创建对象

对象由类来创建

p1 = my_class()
print(p1.x)

>>> 5

init() 函数

init()函数的作用是实现类的每个变量申请内存空间并付初值。需要区分的是init函数和new函数，new函数是创建类，init是一个初始化的方法。

在系统申请内存空间，__init__为类的每个变量申请内存空间并赋值。

所有类都有一个名为 init() 的函数，它始终在启动类时执行。

使用 init() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作

class Person:                              
  def __init__(self, name, age):			 //每次使用类创建新对象时，都会自动调用 __init__() 函数
    self.name = name                        //self 参数是对类的当前实例的引用，用于访问属于该类的变量，可以随意命名，但必须是函数中的首个参数
    self.age = age

p1 = Person("Bill", 34)

print(p1.name)
print(p1.age)

>>> Bill
	34

self

在类内部，就是将所有传入的数据都赋给一个变量，通常这个变量的名字是self。注意，这是习惯，而且是共识

对象方法

对象也可以定义方法。对象中的方法是属于该对象的函数。

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):               #定义方法
    print("hello",self.name)

p1 = Person("Bill", 30)

p1.myfunc()                       #使用方法

>>> hello Bill

修改对象属性

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("Bill", 30)
p1.age = 50                   #修改属性

print(p1.age)

>>> 50

删除

可以使用del关键字删除对象属性，或者对象自身

继承

类的继承

继承允许我们定义继承另一个类的所有方法和属性的类。

父类是继承的类，也称为基类。

子类是从另一个类继承的类，也称为派生类。

创建父类

任何类都可以是父类，因此语法与创建任何其他类相同

# 使用 Person 来创建对象，然后执行 printname 方法：
class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

x = Person("Bill", "Gates")
x.printname()

>>> Bill Gates

创建子类

要创建从其他类继承功能的类，创建子类时将父类作为参数

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  pass                                          //不加pass会报缩进错误
x = Student("Elon", "Musk")
x.printname()

当您添加 init() 函数时，子类将不再继承父的 init() 函数。

子函数的 init() 函数会覆盖对父的 init() 函数的继承。

如需保持父的 init() 函数的继承，请添加对父的 init() 函数的调用

class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)   调用父函数init

super() 函数

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

如果在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承

迭代器

迭代器是一种对象，该对象包含值的可计数数字。

迭代器是可迭代的对象，这意味着您可以遍历所有值。

迭代器是实现迭代器协议的对象，它包含方法 __iter__() 和 __next__()。

迭代器 VS 可迭代对象（Iterable）

列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

所有这些对象都有用于获取迭代器的 iter() 方法

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

>>> apple
	banana
	cherry
#字符串也可以作为迭代对象

创建迭代器

要把对象/类创建为迭代器，必须为对象实现 __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))

#有多少个next语句就会迭代多少次

终止迭代

利用StopIteration控制迭代次数

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 10:
      x = self.a
      self.a += 1
      return x
    else:                    #大于10次停止迭代
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

>>> 1
    2
    3
    4
    5
    6
    7
    8
    9
    10

作用域

变量仅在创建区域内可用。这称为作用域

局部与全局作用域

在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。

x = 200               #在函数外部创建的变量是全局变量,全局变量在任何范围（全局和局部）中可用
def myfunc():
  x = 100             #在函数内部创建的变量在该函数内部以及函数内部的任何函数均可用
  print(x)

myfunc()

print(x)

Global 关键字

使J局部作用域转变为全局作用域

x = 100

def myfunc():
  global x              #定义x为全局作用域
  x = 200

myfunc()

print(x)

>>> 200

模块

定义

模块是包含一组函数的文件，能在应用程序中被引用。

创建模块

模块可以包含已经描述的函数，但也可以包含各种类型的变量（数组、字典、对象等）

任意.py文件都可以看作模块（自己创建的需要保存）

引用模块

#创建test.py,写入以下函数后保存
def hello(name):
    print("hello", name)
    
#创建test2.py

import test   #导入之前写的模块

test.hello("jack")   #使用模块的函数

>>> hello jack

模块内函数用法module_name.function_name

重命名模块

利用as重命名

import test as TEST   #防止冲突

内建模块

python自带的模块，其他模块需要用pip下载

import platform

x = platform.system()
print(x)

>>> Linux

dir()函数

列出模块内所有函数名（变量名）

import platform

x = dir(platform)
print(x)

>>> ['_Processor', '_WIN32_CLIENT_RELEASES', '_WIN32_SERVER_RELEASES',........

dir() 函数可用于所有模块,包括自己创建的

选择性导入

#定义test模块
def hello(name):
    print("hello", name)

person1 = {
  "name": "Bill",
  "age": 63,
  "country": "USA"
}

#导入
from test import  person1

print (person1["age"])

>>> 63

JSON

定义

JSON 是用于存储和交换数据的语法。

JSON 是用 JavaScript 对象表示法（JavaScript object notation）编写的文本。

json数据转换

json转pytrhon

import json

x =  '{ "name":"Bill", "age":63, "city":"Seatle"}' #定义一组json数据

y = json.loads(x)                                   #解析

print(type(x))
print(type(y))

print(y["age"])

>>> <class 'str'>                  #未转换之前是str
	<class 'dict'>                 #解析之后变成了字典
	63							   #正常取值也没问题

pytrhon转json

import json

print(json.dumps({"name": "Bill", "age": 63}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))


>>> {"name": "Bill", "age": 63}
    ["apple", "bananas"]
    ["apple", "bananas"]
    "hello"
    42
    31.76
    true
    false
    null

格式化结果

indent 参数定义缩进数

separators 参数来更改默认分隔符 // 默认值为（", ", ": "）表示使用逗号和空格分隔每个对象，使用冒号和空格将键与值分开

json.dumps(x, indent=4, separators=(". ", " = "))

sort_keys 参数来指定是否应对结果进行排序

json.dumps(x, indent=4, sort_keys=True)

正则表达式RegEx

RegEx 或正则表达式是形成搜索模式的字符序列。

RegEx 可用于检查字符串是否包含指定的搜索模式

re 的内置模块，可用于处理正则表达式

import re

txt = "China is a great country"
x = re.search("^China.*country$", txt)

>>> <re.Match object; span=(0, 24), match='China is a great country'>  #返回macth对象

re 模块提供了一组函数，允许我们检索字符串以进行匹配

函数	描述
findall	返回包含所有匹配项的列表
search	如果字符串中的任意位置存在匹配，则返回 Match 对象
split	返回在每次匹配时拆分字符串的列表
sub	用字符串替换一个或多个匹配项

import re

str = "China is a great country"
x = re.search(r"\bC\w+", str)    r代表原始字符串，\b是前面说到的特殊序列
print(x.span())

>>> (0, 5)                                  # 如果没有匹配项，则返回值 None，而不是 Match 对象

Match 对象

• Match 对象是包含有关搜索和结果信息的对象
• 如果没有匹配，则返回值 None，而不是 Match 对象

import re

str = "China is a great country"
x = re.search("a", str)
print(x) # 将打印一个对象

>>> <re.Match object; span=(4, 5), match='a'>

Match 对象提供了用于取回有关搜索及结果信息的属性和方法：

• span() 返回的元组包含了匹配的开始和结束位置
• .string 返回传入函数的字符串
• group() 返回匹配的字符串部分

元字符

元字符是具有特殊含义的字符

字符	描述	示例
[]	一组字符	“[a-m]”
\	示意特殊序列（也可用于转义特殊字符）	“\d”
.	任何字符（换行符除外）	“he…o”
^	起始于	“^hello”
$	结束于	“world$”
*	零次或多次出现	“aix*”
+	一次或多次出现	“aix+”
{}	确切地指定的出现次数	“al{2}”
|	两者任一	“falls|stays”
()	捕获和分组

特殊序列

字符	描述	示例
\A	如果指定的字符位于字符串的开头，则返回匹配项	“\AThe”
\b	返回指定字符位于单词的开头或末尾的匹配项	r"\bain" r"ain\b"
\B	返回指定字符存在的匹配项，但不在单词的开头（或结尾处）	r"\Bain" r"ain\B"
\d	返回字符串包含数字的匹配项（数字 0-9）	“\d”
\D	返回字符串不包含数字的匹配项	“\D”
\s	返回字符串包含空白字符的匹配项	“\s”
\S	返回字符串不包含空白字符的匹配项	“\S”
\w	返回一个匹配项，其中字符串包含任何单词字符 （从 a 到 Z 的字符，从 0 到 9 的数字和下划线 _ 字符）	“\w”
\W	返回一个匹配项，其中字符串不包含任何单词字符	“\W”
\Z	如果指定的字符位于字符串的末尾，则返回匹配项	“Spain\Z”

集合（Set）

集合（Set）是一对方括号 [] 内的一组字符，具有特殊含义

集合	描述
[arn]	返回一个匹配项，其中存在指定字符（a，r 或 n）之一
[a-n]	返回字母顺序 a 和 n 之间的任意小写字符匹配项
[^arn]	返回除 a、r 和 n 之外的任意字符的匹配项
[0123]	返回存在任何指定数字（0、1、2 或 3）的匹配项
[0-9]	返回 0 与 9 之间任意数字的匹配
[0-5][0-9]	返回介于 0 到 9 之间的任何数字的匹配项
[a-zA-Z]	返回字母顺序 a 和 z 之间的任何字符的匹配，小写或大写
[+]	在集合中，+、*、.、|、()、$、{} 没有特殊含义，因此 [+] 表示：返回字符串中任何 + 字符的匹配项

findall() 函数

findall() 函数返回包含所有匹配项的列表

import re

str = "China is a great country"
x = re.findall("a", str)

print(x)

>>> ['a', 'a', 'a']
---------------------------------------
import re

str = "China is a great country"
x = re.findall("A", str)             #搜索不存在的字符

print(x)

>>> []                               #返回空列表

search() 函数

search() 函数搜索字符串中的匹配项，如果存在匹配则返回 Match 对象。

import re

str = "China is a great country"
x = re.search("\s", str)
print("The first white-space character is located in position:", x.start())
print(x)

>>> The first white-space character is located in position: 5
	<re.Match object; span=(5, 6), match=' '>
	
# 未找到匹配，则返回值 None

split() 函数

split() 函数返回一个列表，其中字符串在每次匹配时被拆分

import re

str = "China is a great country"
x = re.split("\s", str)
print(x)

>>> ['China', 'is', 'a', 'great', 'country']  #可以通过指定 maxsplit 参数来控制出现次数

sub() 函数

sub() 函数把匹配替换为您选择的文本

import re

str = "China is a great country"
x = re.sub("\s", "  ", str)             #将空白字符替换为2个空格
print(x)

----------------------

import re

str = "China is a great country"
x = re.sub("\s", "  ", str,2)           #通过指定 count 参数来控制替换次数
print(x)

>>> China  is  a great country          

PIP包管理

pip3 config set global.index-url https://mirrors.aliyun.com/pypi/simple/  #使用阿里源
pip3 config get global.index-url
pip3 config set global.trusted-host mirrors.aliyun.com                    #信任地址

pip install -i https://pypi.doubanio.com/simple/ --trusted-host    #使用豆瓣源
pypi.doubanio.com pillow											#下载pillow模块

其他源

清华：https://pypi.tuna.tsinghua.edu.cn/simple。
阿里云：http://mirrors.aliyun.com/pypi/simple/。
中国科技大学: https://pypi.mirrors.ustc.edu.cn/simple/。
华中理工大学：http://pypi.hustunique.com/。
山东理工大学：http://pypi.sdutLinux.org/ 。
豆瓣：http://pypi.douban.com/simple/

Try Except

try 块允许您测试代码块以查找错误。

except 块允许您处理错误。

finally 块允许您执行代码，无论 try 和 except 块的结果如何。

异常处理

当我们调用 Python 并发生错误或异常时，通常会停止并生成错误消息。

可以使用 try 语句处理这些异常：

# x = 10                               #未注释前值为 
try:
  print(x)
except:
  print("An exception occurred")
  
  
>>> An exception occurred             #由于x未定义，抛出错误为我们自己定义的语句

多个异常

根据需要定义任意数量的 exception 块来指定不同的错误

如果 try 块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息：

try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")

如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块。

引发异常

作为 Python 开发者，您可以选择在条件发生时抛出异常。

如需抛出（引发）异常，请使用 raise 关键词

可以定义所引发异常的类型、以及打印给用户的文本。

x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allowed")
  
>>> TypeError: Only integers are allowed

常用

• 查看模块包含的函数

dir(module)

• 查看函数具体用法

help(math.pow)