概述

基本来源于菜鸟教程

入门

简介

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

1. 环境
2. 需配置一些环境变量，暂不做 https://www.runoob.com/python3/python3-install.html
3. 运行
4. python fileName.py运行
5. 用vs code右键

数据类型

1. 多行语句。Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，例如：

   1 2 3 4 5 6 7

   item_one = 1 item_two = 2 item_three = 2 total = item_one + \ item_two + \ item_three print(total) # 5

变量

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

2. 允许你同时为多个变量赋值
   a = b = c = 1
   a, b, c = 1, true, “demo”

3. Import

4. 在 python 用 import 或者 from…import 来导入相应的模块。

5. 将整个模块(somemodule)导入，格式为： import somemodule

6. 从某个模块中导入某个函数,格式为： from somemodule import somefunction

7. 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

8. 将某个模块中的全部函数导入，格式为： from somemodule import *

9. Python3 中有六个标准的数据类型：

10. Number（数字）

11. String（字符串）

12. List（列表）

13. Tuple（元组）

14. Set（集合）

15. Dictionary（字典）

16. Python3 的六个标准数据类型中：

17. 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
    1. 其实是指字符串中某个字符不可改变. Eg. str = ‘abc’; str[1] = ‘d’这种是不行的

18. 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

19. 内置的 type() 函数 可以用来查询变量所指的对象类型

    1 2 3

    a, b, c, d = 20, 5.5, True, 4+3j print(type(a), type(b), type(c), type(d)) # <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

20. 此外还可以用 isinstance 来判断：

    1 2 3

    a = 111 isinstance(a, int) # True

21. 使用del语句删除一个或多个对象引用

    1 2	del var del var_a, var_b

字符串

1. 单引号 ‘ 和双引号 “ 使用完全相同；使用三引号 ‘’’ 或 “”” 可以指定一个多行字符串
   word = ‘字符串’
   sentence = “这是一个句子。”
   paragraph = “””这是一个段落，
   可以由多行组成”””

2. Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   str='123456789' print(str) # 输出字符串 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 print(str[0]) # 输出字符串第一个字符 print(str[2:5]) # 输出从第三个开始到第五个的字符 print(str[2:]) # 输出从第三个开始后的所有字符 print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2） print(str * 2) # 输出字符串两次 print(str + '你好') # 连接字符串 print('------------------------------') print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符 print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义 ----------------------------输出部分------------------------------------------- 123456789 12345678 1 345 3456789 24 123456789123456789 123456789你好 ------------------------------ hello runoob hello\nrunoob

3. 字符串函数

4. capitalize()：首字转大写

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

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

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

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

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

10. index(str, beg=0, end=len(string))：跟find()方法一样，只不过如果str不在字符串中会报一个异常

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

12. lower()：转换字符串中所有大写字符为小写

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

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

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

17. isdigit()：如果字符串只包含数字则返回 True 否则返回 False.

数字

python中数字有四种类型：整数int、布尔型bool（？？）、浮点数float和复数complex

1. Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加。True==1、False==0 会返回 True，但可以通过 is 来判断类型

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   print(issubclass(bool, int)) # True print(True==1) # True print(False==0) # True print(True+1) # 2 print(False+1) # 1 print(1 is True) # False print(0 is False) # False

2. 数字运算

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   >>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32

3. 数学函数
4. abs(x) 绝对值
5. ceil(x) 向上取整
6. floor(x) 向下取整
7. round(x [,n]) 浮点数x的四舍五入
8. exp(x) 常数e的x次幂
9. pow(x, y) x^y
10. sqrt(x) x的平方根
11. max(a, b, c…) 最大值
12. min(a, b, c…) 最小值
13. 随机数函数
14. choice(seq): 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
15. randrange ([start,] stop [,step]): 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
16. random(): 随机生成下一个实数，它在[0,1)范围内
17. shuffle(lst): 将序列的所有元素随机排序
18. uniform(x, y): 随机生成下一个实数，它在[x,y]范围内

List列表

1. 基础

   1 2 3 4 5 6 7 8 9

   list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] tinylist = [123, 'runoob'] print (list) # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2] print (list[0]) # 输出列表第一个元素 abcd print (list[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23] print (list[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2] print (tinylist * 2) # 输出两次列表 [123, 'runoob', 123, 'runoob'] print (list + tinylist) # 连接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

2. Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 (包含开始，不包含结束)的位置并设置为步长为 2（间隔一个位置）来截取字符串：

   1 2 3 4

   letters = ['j', 'a', 'c', 'l', 'e', 'k', 'l', 'm'] print(letters[1:4:2]) # ['a', 'l'] print(letters[1:5:2]) # ['a', 'l'] print(letters[1:6:2]) # ['a', 'l', 'k']

• 如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串（有一说一不好理解）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  def reverseWords(input): # 通过空格将字符串分隔符，把各个单词分隔为列表 inputWords = input.split(" ") # 翻转字符串 # 假设列表 list = [1,2,3,4], # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) # inputWords[-1::-1] 有三个参数 # 第一个参数 -1 表示最后一个元素 # 第二个参数为空，表示移动到列表末尾 # 第三个参数为步长，-1 表示逆向 inputWords=inputWords[-1::-1] # 重新组合字符串 output = ' '.join(inputWords) return output input = 'I like python' rw = reverseWords(input) print(rw) # python like I

1. 常用方法
2. list.append(1) 。添加元素 1
3. list.insert(idx, obj)
4. list.pop([idx=-1])
5. list.remove(obj)
6. del list[3] 删除idx 3元素
7. list.count(obj) 元素出现的次数
8. list.index(obj) 返回idx
9. list.reverse()
10. list.sort( key=None, reverse=False)：排序
11. list.clear()
12. list.copy()
13. List 间 的 + ，是组合
14. list * 某个num，是重复几次
15. for x in [1, 2, 3]: print(x, end=” “)。迭代

Tuple元组

1. 元组（tuple）与列表类似，不同之处在于元组的元素不能修改（像 tup[0] = 11 这种是不允许的），也不能删除某个元素。元组写在小括号 () 里，元素之间用逗号隔开
   虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
   string、list 和 tuple 都属于 sequence（序列）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 print (tuple + tinytuple) # 连接元组 输出： ('abcd', 786, 2.23, 'runoob', 70.2) abcd(786, 2.23) (2.23, 'runoob', 70.2) (123, 'runoob', 123, 'runoob') ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

2. 包含0个或1个元素的元组，语法比较特殊：
   tup1 = () # 空元组
   tup2 = (20,) # 一个元素，需要在元素后添加逗号

Set（集合）

1. 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。
2. 可以使用大括号 { } 或者 set() 函数创建集合
   注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
   sites = {‘Google’, ‘Taobao’, ‘Google’, ‘Facebook’, ‘Zhihu’, ‘Baidu’}
   print(sites) # 输出集合，重复的元素被自动去掉 {‘Baidu’, ‘Facebook’, ‘Google’, ‘Zhihu’, ‘Taobao’}

成员测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

if 'RuGooglenoob' in sites :
  print('Runoob 在集合中')
else :
  print('Runoob 不在集合中') # Runoob 不在集合中

# # set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)    # a 和 b 的差集
print(a | b)    # a 和 b 的并集
print(a & b)    # a 和 b 的交集
print(a ^ b)    # a 和 b 中不同时存在的元素

{'a', 'c', 'r', 'd', 'b'}
{'b', 'r', 'd'}
{'a', 'm', 'z', 'c', 'r', 'd', 'l', 'b'}
{'c', 'a'}
{'r', 'm', 'b', 'd', 'z', 'l'}

3. 常见方法
4. set.add()
5. set.clear()
6. set.copy()
7. remove() 移除指定元素
8. difference() 返回多个集合的差集
9. intersection() 返回集合的交集
10. discard() 删除集合中指定的元素
    Dictionary（字典）
11. 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
12. 键(key)必须使用不可变类型；在同一个字典中，键(key)必须是唯一的。

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

    dict = {} dict['one'] = "1 - 菜鸟教程" dict[2] = "2 - 菜鸟工具" tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} dict3(sape=4139, guido=4127, jack=4098) # {'sape': 4139, 'jack': 4098, 'guido': 4127} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值 输出： 1 - 菜鸟教程 2 - 菜鸟工具 {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'} dict_keys(['name', 'code', 'site']) dict_values(['runoob', 1, 'www.runoob.com'])

13. 常用方法
14. len()。返回键的总数
15. str(dict)。输出字典字符串
16. dict.clear()
17. dict.copy()
18. dict.get(key)
19. dict.setdefault(key, default=None): 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
20. key in dict: 如果键在字典dict里返回true，否则返回false
21. dict.keys()
22. dict.items(): 以列表返回一个视图对象.eg. 返回 dict_items([(‘Name’, ‘Runoob’), (‘Age’, 7), (‘Class’, ‘First’)])
23. dict.values()
24. dict.update(dict2): 把字典dict2的键/值对更新到dict里
25. pop(key[,default]): 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值
26. popitem(): 返回并删除字典中的最后一对键和值
    Python数据类型转换
    https://www.runoob.com/python3/python3-type-conversion.html

• 隐式类型转换。我们对两种不同类型的数据进行运算，较低数据类型（eg. 整数）就会转换为较高数据类型（eg. 浮点数）以避免数据丢失
  • 当然也有转换不了的。eg. 整型数据与字符串类型的数据进行相加，会报错因为转换不了
• 显式类型转换。 int()、float()、str() 等
  Python 推导式
  推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构，支持list、dict、set、tuple推导式

1. list推导式
   [out_exp_res for out_exp in input_list]
   或者
   [out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值
  整体含义：执行后面的for 和 if 部分，满足的条件的就执行 out_exp_res 部分产出最后结果
  例子：

  1 2 3 4

  names = ['Bob','Tom','alice','Jerry','Wendy','Smith'] new_names = [name.upper()for name in names if len(name)>3] print(new_names) # ['ALICE', 'JERRY', 'WENDY', 'SMITH']

2. Dict推导式

   1 2 3

   { key_expr: value_expr for value in collection } 或 { key_expr: value_expr for value in collection if condition }

   同理，看这个case即能理解：

   1 2 3 4

   listdemo = ['Google','Runoob', 'Taobao'] newdict = {key:len(key) for key in listdemo} print(newdict) # {'Google': 6, 'Runoob': 6, 'Taobao': 6}

3. Set推导式

   1 2 3

   { expression for item in Sequence } 或 { expression for item in Sequence if conditional }

4. 元组tuple推导式

   1 2 3

   (expression for item in Sequence ) 或 (expression for item in Sequence if conditional )

运算符

1. 运算符。除了常规的，还有
2. ** 为幂。a**b 为 a^b
3. // 为取整除。eg. 9//2 == 4
4. := 为海象运算符，一般用在表达式内部为变量赋值

   1 2 3 4

   if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") # 这个if即判断了 if (len(a)) > 10, 又把 n 赋值为 len(a)

5. 逻辑运算符（不是 ||、&&、! 这样），是：and、or、not
6. 成员运算符：in、not in
7. 身份运算符：is、not is
8. 运算符优先级。略

编程

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

1
2
3
4
5
6
7

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b
# 结果：1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

循环

1. While

   1 2 3 4 5

   sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1

2. For

   1 2 3 4

   for <variable> in <sequence>: <statements> else: <statements>

3. range()。如果你需要遍历数字序列，可以使用内置range()函数，它会生成数列。eg：

   1 2 3 4 5 6

   for i in range(3): print(i) # 0 # 1 # 2 # 3

• 以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做’步长’).eg. for i in range(0, 10, 3) 。0到10，每步为3

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   for letter in 'Runoob': if letter == 'o': pass print ('执行 pass 块') print ('当前字母 :', letter) print ("Good bye!") # 输出： 当前字母 : R 当前字母 : u 当前字母 : n 执行 pass 块 当前字母 : o 执行 pass 块 当前字母 : o 当前字母 : b Good bye!

迭代器 与 生成器

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

   1 2 3 4

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

4. 生成器 yield。在 Python 中，使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象
   函数
   函数以 def 开头，而不是func或function这种，而且也没有 { } 这种边界，完全考层级肉眼区分
5. 参数
6. 默认参数。和 js 一致
7. 不定长参数。
   1. 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

   1 2 3 4 5 6

   def printMoreArgs(a, *morArgs): print("a is", a) print("morArgs is", morArgs) # morArgs is (5, 6, 'jacle') print(type(morArgs)) # <class 'tuple'> printMoreArgs(4, 5, 6, "jacle")

1. 加了两个星号 ** 的参数会以字典的形式导入

1
2
3
4
5
6
7

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict) # {'name': 'jacle', 'age': '21'}

printinfo(1, name='jacle',age='21')

2. 匿名函数。Python 使用 lambda 来创建匿名函数。语法如下
   lambda [arg1 [,arg2,.....argn]]:expression

Eg.

1
2

x = lambda a : a + 10
print(x(5))

模块

1. import

   1 2 3

   import module module.method(args)

2. from … import

   1	from module import method1[, method2[, ... methodN]]

3. from … import * 把一个模块的所有内容全都导入到当前的命名空间
4. __name__属性。每个模块都有这个属性，用来识别该模块是「自身在运行」，还是「被引用后」在运行

   1 2 3 4 5

   # path: ./mod1.py if __name__ == '__main__': print('程序自身在运行') else: print('我来自另一模块')

   直接运行 python ./mod1，会打印出 程序自身在运行；

   1 2	# path: ./mod2.py import mod1

   若是被其他模块引用后运行，则打印出 我来自另一模块
   命名空间和作用域链
   感觉和js差不多
   面向对象
   用class关键字创建类
   错误和异常
5. try/expcept语句
6. try/expcept…else语句
   常用功能
   输入输出
   正则
   JSON
   日期和时间
   File
   OS

https://www.runoob.com/python3/python3-function.html