Python Basic Knowledge

Python

 2022/04/30 

概述

基本来源于菜鸟教程

入门

简介

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

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

数据类型

多行语句。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

变量

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建；Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型
允许你同时为多个变量赋值
a = b = c = 1
a, b, c = 1, true, “demo”
Import
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
1. 其实是指字符串中某个字符不可改变. Eg. str = ‘abc’; str[1] = ‘d’这种是不行的
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

内置的 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'>

此外还可以用 isinstance 来判断：
1
2
3
a = 111
isinstance(a, int)
# True
使用del语句删除一个或多个对象引用
1
2
del var
del var_a, var_b

字符串

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

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

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

字符串函数
capitalize()：首字转大写
count(str, beg= 0,end=len(string))：返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
endswith(suffix, beg=0, end=len(string))：检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
startswith(substr, beg=0,end=len(string))：检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查
split(str=””, num=string.count(str))：以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))：跟find()方法一样，只不过如果str不在字符串中会报一个异常
rfind(str, beg=0,end=len(string))：类似于 find()函数，不过是从右边开始查找
lower()：转换字符串中所有大写字符为小写
replace(old, new [, max])：把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次
isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False
isalpha()：如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()：如果字符串只包含数字则返回 True 否则返回 False.

数字

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

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

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

数字运算

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

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

List列表

基础

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']

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']

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

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

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

Tuple元组

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

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')

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

Set（集合）

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

成员测试

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'}

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

键(key)必须使用不可变类型；在同一个字典中，键(key)必须是唯一的。

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'])

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

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

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']

Dict推导式

1
2
3

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

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

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

Set推导式

1
2
3

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

元组tuple推导式

1
2
3

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

运算符

运算符。除了常规的，还有
** 为幂。a**b 为 a^b
// 为取整除。eg. 9//2 == 4

:= 为海象运算符，一般用在表达式内部为变量赋值

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

# 这个if即判断了 if (len(a)) > 10, 又把 n 赋值为 len(a)

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

编程

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

# 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,

循环

While

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

For

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

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

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

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!

迭代器与生成器

迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退
迭代器有两个基本的方法：iter() 和 next()

字符串，列表或元组对象都可用于创建迭代器

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

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

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

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. 加了两个星号 ** 的参数会以字典的形式导入

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

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

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

Eg.

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

模块

import
1
2
3
import module

module.method(args)

from … import

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

from … import * 把一个模块的所有内容全都导入到当前的命名空间
__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关键字创建类
错误和异常
try/expcept语句
try/expcept…else语句
常用功能
输入输出
正则
JSON
日期和时间
File
OS