参考 B 站 IT 私塾的视频 Python 爬虫编程基础 5 天速成（2021 全新合集）Python 入门+数据分析。
Doc: Python - W3Schools
H1Comment
H2Single-line Comment
python
# 我是注释，可以在里写一些功能说明之类的哦
print('hello world')H2Multiline Comment
python
'''
我是多行注释，
可以写很多很多行的功能说明
哈哈哈。。。
'''
print('hello world')H1Output
H2普通输出
print('hello world')
H2格式化输出
python
age = 21
print("我今年%d岁"% age)在程序中，看到了%这样的操作符，这就是 Python 中格式化输出。
再来一个Example:
python
age = 21
name = "HarrisWong"
print("我的姓名是%s,年龄是%d"%(name,age))H4常用的格式符号
| 格式符号 | 转换 |
|---|---|
| %c | 字符 |
| %s | 通过 str() 字符串转换来格式化 |
| %i | 有符号十进制整数 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写字母） |
| %X | 十六进制整数（大写字母） |
| %e | 索引符号（小写'e'） |
| %E | 索引符号（大写'E'） |
| %f | 浮点实数 |
| %g | ％f 和％e 的简写 |
| %G | ％f 和％E 的简写 |
H3换行输出
在输出的时候，如果有\n那么，此时\n后的内容会在另外一行显示
python
print("1234567890-------") # 会在一行显示
print("1234567890\n-------") # 一行显示1234567890，另一行-------H1Input
先看一个Example:
python
password = input("请输入密码:")
print('您输入的密码是:', password)-
input()的小括号中放入的是，提示信息，可省略
-
input()在从键盘获取了数据以后，会存放到等号左边的变量中
-
input()函数接受的输入必须是表达式
H1Operators & Expressions
H2Arithmetic Operators 算术运算符
| Operators | Desc |
|---|---|
| + | 加：两个对象相加 |
| - | 减：得到负数或是一个数减去另一个数 |
| * | 乘 |
| / | 除：x 除以 y |
| % | 取模：返回除法的余数 |
| ** | 幂：返回 x 的 y 次幂 |
| // | 取整除：向下取接近除数的整数 |
H2Logical Operators 逻辑运算符
| Operators | Desc |
|---|---|
| not | Logical inverse, not |
| and | Logical AND |
| or | Logical OR |
H2Comparison Operator 比较运算符
| Operators | Desc |
|---|---|
| == | 等于：比较对象是否相等 Note: We can use == check if two lists are identical |
| != | 不等于：比较两个对象是否不相等 |
| > | 大于：返回 x 是否大于 y |
| < | 小于：返回 x 是否小于 y。所有比较运算符返回 1 表示真返回 0 表示假。这分别与特殊的变量 True 和 False 等价 |
| >= | 大于等于：返回 x 是否大于等于 y |
| <= | 小于等于：返回 x 是否小于等于 y |
H2Assignment Operator 赋值运算符
| Operators | Desc |
|---|---|
| = | 简单的赋值运算符 |
| += | 加法赋值运算符 |
| -= | 减法赋值运算符 |
| *= | 乘法赋值运算符 |
| /= | 除法赋值运算符 |
| %= | 取模赋值运算符 |
| **= | 幂赋值运算符 |
| //= | 取整除赋值运算符 |
H2Membership Operators
| Operators | Desc |
|---|---|
| in | Returns True if a sequence with the specified value is present in the object |
| not in | Returns True if a sequence with the specified value is not present in the object |
H2Star or Asterisk operator ( * )
H3Multiplication of a List/String
python
name = "H"
print(name * 8) # HHHHHHHH
girls = ["Sharon", "Wendy"]
print(girls * 2) # ['Sharon', 'Wendy', 'Sharon', 'Wendy']H3Spread Operation
python
# List
numbers = [1, 2, 3]
print(*numbers) # Output: 1 2 3
fruits = ['apple', 'banana']
more_fruits = ['orange', 'kiwi']
combined_fruits = [*fruits, *more_fruits]
print(combined_fruits) # Output: ['apple', 'banana', 'orange', 'kiwi']
# Dict
first_dict = {'a': 1, 'b': 2}
second_dict = {'c': 3, 'd': 4}
merged_dict = {**first_dict, **second_dict}
print(merged_dict) # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}H1If…Else
H2if
python
age = 100
if age >= 18:
print "我已经成年了"Short Hand: if a > b: print("a is greater than b")
H2if-else
python
if True:
print ("True")
else:
print ("False")Short Hand: print("A") if a > b else print("B")
This technique is known as Ternary Operators, or Conditional Expressions.
H2elif
python
score = 98
if 90 <= score and score <= 100:
print('好棒呀')
elif 80 <= score:
print('还不错')
else:
print('继续加油哦')H1Loops
H2for
Example:
python
name = 'harris'
for x in name:
print(x)
# h a r r i sH2while
Example:
python
i = 0
while i<5:
print("当前是第%d次执行循环"%(i+1))
print("i=%d"%i)
i+=1H3break、continue、pass
- break 语句可以跳出 for 和 while 的循环体
- continue 语句可以跳出当前循环，直接进行下一轮循环
- pass 是空语句，一般用做占位语句，不做任何事情
H1import
在 python 用 import 或者 from import 来导入相应的模块。
将整个模块(somemodule)导入，格式为：import somemodule
从某个模块中导入某个函数,格式为：from somemodule import somefunction
从某个模块中导入多个函数,格式为：from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import \*
Example:生成随机数:
- 第一行代码引入库：
import random #引入随机库 - 生成指定范围的随机数：
harris = random.randint(0,2)随机生成 0、1、2 中的一个数字，赋值给变量harris
H1Numbers
H1Math
H2Built-in Math Functions
| Methods | Desc |
|---|---|
| min() | Find the lowest value in an iterable |
| max() | Find the highest value in an iterable |
| abs() | Returns the absolute (positive) value of the specified number |
H2The Math Module
| Methods | Desc |
|---|---|
| math.ceil(8.9) | Rounds a number upwards to its nearest integer |
| math.floor(8.9) | Rounds a number downwards to its nearest integer |
| math.sqrt(9) | Returns the square root of a number |
H1Built in Functions
H2filter()
The filter() function returns an iterator where the items are filtered through a function to test if the item is accepted or not.
Syntax: filter(function, iterable)
python
ages = [5, 12, 17, 18, 24, 32]
def myFunc(x):
return x >= 18
adults = filter(myFunc, ages)
for x in adults:
print(x)H2sorted()
The sorted() function returns a sorted list of the specified iterable object.
Syntax: sorted(iterable, [key=key], [reverse=reverse])
python
def myfunc(n):
return abs(10-n)
a = (5, 3, 1, 11, 2, 12, 17)
x = sorted(a, key=myfunc)
print(x)
# [11, 12, 5, 3, 17, 2, 1]H2reversed()
Returns a reversed iterator object.
python
alph = ["a", "b", "c", "d"]
ralph = list(reversed(alph))
print(ralph) # ['d', 'c', 'b', 'a']H2ord()
The ord() function returns the number representing the unicode code of a specified character.
H2chr()
The chr() function returns the character that represents the specified unicode.
H2enumerate()
The enumerate() function takes a collection (e.g. a tuple) and returns it as an enumerate object.
The enumerate() function adds a counter as the key of the enumerate object.
Syntax: enumerate(iterable, start=0)
python
for i, ele in enumerate(l):
print(i, ele)H2zip()
The zip() function returns a zip object, which is an iterator of tuples where the first item in each passed iterator is paired together, and then the second item in each passed iterator are paired together etc.
If the passed iterables have different lengths, the iterable with the least items decides the length of the new iterator.
python
a = ("John", "Charles", "Mike")
b = ("Jenny", "Christy", "Monica", "Vicky")
x = zip(a, b)
# (('John', 'Jenny'), ('Charles', 'Christy'), ('Mike', 'Monica'))H2round()
Syntax: round(number, digits)
H1Keyword
H2is
It's used to test if two variables refer to the same object.
python
x = ["apple", "banana", "cherry"]
y = x
print(x is y)H1Strings
H2Operators
Example: a = "Hello", b = "Python"
| 操作符 | Desc | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定字符则返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
H2字符串的截取和连接
python
str='harriswong'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print(str[:5]) # 输出第五个字母前的所有字符
print(str[0:7:2]) # [起始：终止：步长]
print('hello\npython') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\npython') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义H2Formatting
F-string allows you to format selected parts of a string.
python
price = 89
txt = f"The price is {price} dollars"
print(txt)H2Methods
| 函数 | 描述 |
|---|---|
| len(S) | 返回 S 字符串长度 |
| str.join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| lower() | 转换字符串中所有大写字符为小写 |
| upper() | 转换字符串中的小写字母为大写 |
| lstrip() | 截掉字符串左边的空格或指定字符 |
| rstrip() | 截掉字符串字符串末尾的空格 |
| max(str) | 返回字符串 str 中最大的字母 |
| min(str) | 返回字符串 str 中最小的字母 |
| S.format () | "{} {}".format("hello", "world") # 不设置指定位置，按默认顺序'hello world' "{0} {1}".format("hello", "world") # 设置指定位置'hello world' "{1} {0} {1}".format("hello", "world") # 设置指定位置'world hello world' |
H3replace()
str.replace(old, new[, max])
参数：
old: 将被替换的子字符串。new: 新字符串，用于替换 old 子字符串。max: 可选字符串, 替换不超过 max 次。
H3split()
str.split(str="", num=string.count(str)).
参数：
str: 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。num: 分割次数。默认为 -1, 即分隔所有。
Example:
python
str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split(); # 以空格为分隔符，包含 \n
print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个
#结果：
#['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
#['Line1-abcdef', '\nLine2-abc \nLine4-abcd']H1Lists 列表
H2Loop
python
namesList = ['harris','wendy','sharon']
for name in namesList:
print(name)H2Functions
| 函数 | Desc |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(tuple) | 将元组转换为列表 |
H2Methods
| 方法 | Desc |
|---|---|
| list.append(ele) | 在列表末尾添加ele |
| list.count(ele) | 统计 ele 在列表中出现的次数 |
| list.extend(arr) | Adds the specified list elements (or any iterable) to the end of the current list. |
| list.index(ele) | 查找列表中值为 ele 第一个匹配项的索引位置 |
| list.insert(index, ele) | 将 ele 插入列表下标为 index |
| list.pop(index) | 移除下标为 index 的元素，并返回该元素的值. default value is -1, which returns the last item |
| list.remove(ele) | 移除列表中值为 ele 的第一个匹配项 |
| list.reverse() | 反转列表中元素 |
| list.sort(key = None, reverse= False) | 对原列表进行排序（见下） |
| list.clear() | 清空列表 |
| list.copy() | 复制列表 |
H3sort()
key 可以指定一个排序方法；reverse = True 降序， reverse = False 升序（默认）。
案例：（按照第二个元素排序并输出）
python
def takeSecond(List):
return List[1]
List = [(2,2), (4,1), (1,3)]
List.sort(key=takeSecond, reverse=True)
print('降序列表：', List)输出结果：降序列表：[(1,3), (2,2), (4,1)]
H1Tuples 元组
-
A tuple is a collection which is ordered and unchangeable.
-
Tuples are written with round brackets
(). -
但可以包含可变对象，如 list。
注意：定义只有 1 个元素的 tuple，必须加逗号，否则被当为整型 int。如：
t = (1,)
H2函数
| 函数 | 描述 |
|---|---|
| len(tuple) | 计算元组元素个数 |
| max(tuple) | 返回元组中元素最大值 |
| min(tuple) | 返回元组中元素最小值 |
| tuple(list) | 将列表转换为元组 |
H1Sets 集合
-
集合 set 和字典 dict 类似，也是一组 key 的集合，但不存储 value，由于 key 不能重复，所以在 set 中没有重复的 key。
-
set 是无序的，重复元素在 set 中自动被过滤。
H2Methods
| Methods | Desc |
|---|---|
| for i in s1: print(i) | 遍历集合 |
| s1.add(ele) | 向集合添加新元素 |
| s1.remove(ele) | 移除集合中的元素 |
| val = s1.pop() | 弹出元素 |
| s1.clear() | 清除元素 |
| del s1 | 删除元组 |
| s1.update(s2) s1 |= s2 | 更新集合（合并） |
| s1.difference(s2) s1 - s2 | Return a new set that will contain only the items from the first set that are not present in the other set. |
| s1.intersection(s2) s1 & s2 | Return a new set, that only contains the items that are present in both sets. |
| s1.symmetric_difference(s2) s1 ^ s2 | Keep only the elements that are NOT present in BOTH sets. |
| len() | 获取集合长度 |
| max() | 获取最大的元素 |
| min() | 获取最小的元素 |
| set() | 其它类型对象转换成集合 |
H1Dictionaries 字典
H2Loop
python
for key in dict:
print(key, dict[key])
for key, val in dict.items():
print(key, val)
for val in dict.values():
print(val)H2Methods
Example: dict = {'Name': 'harris', 'Age': 20, 'Class': 'three'}
| Methods | Desc |
|---|---|
| dict['harris'] | 通过 key 来访问元素并打印，不存在会抛出异常 |
| dict.get('harris' | 通过 get 方法来访问元素，不存在返回 None，不抛出异常 |
| dict.keys() | 获取所有 key |
| dict.values() | 获取所有 value |
| dict['Age'] = 21 | 新增键值对或修改 val |
| del dict['harris'] | 删除元素 |
| dict.pop('harris') | 将元素弹出 |
| 'harris' in dict | 判断元素是否存在 |
| dict.clear() | 清除字典内的元素 |
| len() | 获取字典长度 |
| max() | 获取最大的 key |
| min() | 获取最小的 key |
H3del
python
dict = {'Name': 'harris', 'Age': 20, 'Class': 'three'}
del dict['Name'] # 根据键“Name”来删除
dict.clear() # 清空字典
del dict # 删除字典H3access value by key
python
dict = {'Name': 'harris', 'Age': 20, 'Class': 'three'}
print(dict['Age']) # 获取年龄
# print(dict['Sex']) # 获取不存在的key，会发生异常
print(dict.get('Sex')) # 获取不存在的key，获取到None的空内容，不会出现异常在我们不确定字典中是否存在某个键而又想获取其值时，可以使用 get 方法，还可以设置默认值
python
age = dict.get('Sex') # 'Sex'键不存在，所以age为None
age = dict.get('Sex', '男') # 若dict中不存在'Sex'这个键，就返回默认值'男'H1Functions
H2定义和调用函数
python
def 函数名():
代码
函数名()Example:
python
# 定义一个函数，能够完成打印信息的功能
def printInfo():
print '人生苦短，我用Python'
printInfo();H2带参函数
Example:
python
def add(a, b):
c = a + b
print(c)
add(8, 9) # 17H2带返回值函数
Example:
python
def add(a, b):
return a+b
print(add(8, 9)) # 17H3返回多个值
例子（求商和余数）：
python
def divid(a, b):
quotient = a//b
mod = a%b
return quotient, mod
q, m = divid(5, 2)
print(q, m)H1Lambda - Anonymous Function
H2Syntax
python
lambda arguments : expressionExample:
python
sum = lambda a, b: a + b
print ("相加后的值为:", sum(1, 2)) # 相加后的值为:3H1Generators
A Generator in Python is a function that returns an iterator using the yield keyword
python
def simpleGeneratorFun():
yield 1
yield 2
yield 3
# Driver code to check above generator function
for value in simpleGeneratorFun():
print(value)
# In Python 3, __next__()
print(next(x))
print(next(x))
print(next(x))H1Collections
H2DefaultDict
The functionality of both dictionaries and defaultdict are almost same except for the fact that defaultdict never raises a KeyError. It provides a default value for the key that does not exists.
python
from collections import defaultdict
# Defining a dict
d = defaultdict(list)
for i in range(5):
d[i].append(i)
print("Dictionary with values as list:")
print(d) H1Class
python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def get_a_girl(self):
print("An innocent girl fall in love with " + self.name)
class PlayBoy(Person):
def __init__(self, name, age, num_of_girls):
super().__init__(name, age)
self.num_of_girls = num_of_girls
def show_off(self):
print(f"Hey bro, I got {self.num_of_girls} girls")
p = Person("Harris", 23)
pb = PlayBoy("Jack", 60, 10)
p.get_a_girl()
pb.show_off()H1Files
文件，就是把一些数据存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。
H2文件打开
使用 open 函数，可以打开一个已经存在的文件，或者创建一个新文件
格式：open(文件名，访问模式)
模板：f = open('test.txt', 'w')
说明：
| 访问模式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
H2文件关闭
格式：close()
模板：
python
# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()H2文件写入
使用 write()可以完成向文件写入数据
Example:
python
f = open('test.txt', 'w')
f.write('hello hassan, i am here!')
f.close()注意：如果文件不存在那么创建，如果存在那么就先清空，然后写入数据
H2文件读取
H3read
使用 read(num)可以从文件中读取数据，num 表示要从文件中读取的数据的长度（单位是字节），如果没有传入 num，那么就表示读取文件中所有的数据.
Example:
python
f = open('test.txt', 'r')
content = f.read(5)
print(content)
print("-------------")
content = f.read()
print(content)
f.close()-
如果 open 是打开一个文件，那么可以不用写打开的模式，即只写
open('test.txt') -
如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的
H3readlines
就像 read 没有参数时一样，readlines 可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
python
#coding=utf-8
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()H3readline
一行一行地读取
python
#coding=utf-8
f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()H2文件重命名
os 模块中的 rename()可以完成对文件的重命名操作
格式：rename(需要修改的文件名, 新的文件名)
python
import os
os.rename("毕业论文.txt", "毕业论文-最终版.txt")H2文件删除
os 模块中的 remove()可以完成对文件的删除操作
格式：remove(待删除的文件名)
python
import os
os.remove("毕业论文.txt")H2创建文件夹
python
import os
os.mkdir("张三")H2获取当前目录
python
import os
os.getcwd()H2改变默认目录
python
import os
os.chdir("../")H2获取目录列表
python
import os
os.listdir("./")H2删除文件夹
python
import os
os.rmdir("张三")H1错误与异常
TODO
H1常见问题集锦
pip install 第三方库下载模块速度慢，或者不成功
shell
pip --default-timeout=100 install <库名称> -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com除了豆瓣，也可以换成下面的国内镜像网站。
清华：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/
