Python入门
人生苦短，我用 Python
安装
Mac OS
Mac OS 用户可以直接使用Homebrew安装：
$ brew install python3
$ brew link python3GNU/Linux
GNU/Linux 用户使用系统内置包管理器，如Ubuntu/Debian：
$ sudo apt-get update
$ sudo apt-get install python3Windows
Windows 用户推荐使用PowerShell下的choco安装：
$ choco install -y python3基础操作
查看 Python 版本
$ python -V使用 Python
可以通过以下命令进入环境：
$ python
Python 3.9.5 (tags/v3.9.5:0a7dcbd, May 3 2021, 17:27:52) [MSC v.1928 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>输入exit()即可退出环境
基本数据类型
数据类型
# Number （单行注释）
1 + 1 # 2
1 - 1 # 0
1 * 1 # 1
4 / 2 # 2.0
9 // 2 # 4 （除法并取整）
9.0 // 2.0 # 4.0 （除法并取整，浮点数同样有效）
7 % 3 # 1 (取余)
2 ** 3 # 8 （2 的 3 次方）
# Boolean
True # True
False # False
not True # False
not False # True
True and False # False
True or False # True
True + True # 2
True + False # 1
0 == False # True
1 == True # True
2 == True # False
bool(-6) # True
bool(0) # False
bool("") # False
bool([]) # False
bool({}) # False
bool(()) # False
# String
"string" # 'string'
'string' # 'string'
"Hello " + "world!" # 'Hello world!'
"Hello " "world!" # 'Hello world!'
"Hello world!"[0] # 'H'
len("string") # 6 （字符串长度）
name = "o2" # 变量
f"{name} lab" # o2 lab （这里类似 ES6 里的模板字符串）
# None
None # None
"etc" is None # False
None is None # TrueList（列表）
List（列表）是一种有序的集合，可以随时添加和删除其中的元素。
name = ['aotu', 'lab', 'hello', 'kitty']
# 通过索引来访问列表中的数据
print(name[1]) # lab
# 截取数据
print(name[0:2]) # ['aotu', 'lab']
# 通过索引更新数据
name[1] = 'newbee'
print(name) # ['aotu', 'newbee', 'hello', 'kitty']
# 使用 append() 来添加列表项
name.append('world')
print(name) # ['aotu', 'newbee', 'hello', 'kitty', 'world']
# 使用 del 语句删除列表内的元素
del name[2]
print(name) # ['aotu', 'newbee', 'kitty', 'world']函数&方法 | 描述 |
|---|---|
len(list) | 列表元素个数 |
max(list) | 返回列表元素最大值 |
min(list) | 返回列表元素最小值 |
list(seq) | 将元组转换为列表 |
list.append(obj) | 在列表末尾添加新的对象 |
list.count(obj) | 统计某个元素在列表中出现的次数 |
list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
list.insert(index, obj) | 将对象插入列表 |
list.pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
list.remove(obj) | 移除列表中的一个元素（参数是列表中元素），并且不返回任何值 |
list.reverse() | 反向列表中元素 |
list.sort([func]) | 对原列表进行排序 |
Tuple (元祖)
Tuple一旦初始化就不能修改，所以它是不可变的。它和TypeScript里的Tuple相似，区别在于TypeScript里的元祖的值类型一般为String或Number。
# 创建元祖
tuple1 = (1, 2, 3)
# 创建空元祖
tuple2 = ()
# 元祖只有一个元素时，需在后面添加逗号，否则会创建一个值为 1 的变量
tuple3 = (1,)
# 访问元祖的元素
print(tuple1[0]) # 1
# 元祖内的元素不能删除，但可以删除整个元祖
del tuple2方法 | 描述 |
|---|---|
len(tuple) | 元祖元素个数 |
max(tuple) | 返回元祖元素最大值 |
min(tuple) | 返回元祖元素最小值 |
tuple(seq) | 将列表转换为元祖 |
Dict（字典）
Dict（字典）类似于 JavaScript 里的 object 。
empty_dict = {}
filled_dict = {"one": 1, "two": 2, "three": 3}差别：
方法和函数 | 描述 |
|---|---|
len(dict) | 计算字典元素个数 |
str(dict) | 输出字典可打印的字符串表示 |
type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型 |
dict.clear() | 删除字典内所有元素 |
dict.copy() | 返回一个字典的浅拷贝 |
dict.values() | 以列表返回字典中的所有值 |
popitem() | 随机返回并删除字典中的一对键和值 |
dict.items() | 以列表返回可遍历的(键, 值)元组数组 |
Set
和其他语言类似，Set 是一个无序不重复的元素集合。
# 创建 set
set1 = set([1, 2, 3])
set2 = set([2, 3, 4, 5])
# 交集
set3 = set1 & set2 # {2, 3}
# 并集
set4 = set1 | set2 # {1, 2, 3, 4, 5}
# 差集
set5 = set1 - set2 # {1}
2 in set2 # True方法 | 描述 |
|---|---|
set.add(key) | 添加元素到set中 |
set.remove(key) | 从 set 中删除元素，如果元素不存在则会引发 KeyError |
set.discard(key) | 如果元素存在集合中则将其删除 |
set.pop() | 从集合中移除并返回任意一个元素，如果集合为空则会引发 KeyError |
set.clear() | 从集合中移除所有元素 |
set.copy() | 返回一个 set 的浅拷贝 |
条件语句与循环语句
条件语句
Python 中，if 语句基本形式如下：
if 判断条件:
执行语句
else:
执行语句if 判断条件1:
执行语句
elif 判断条件2:
执行语句
elif 判断条件3:
执行语句
else:
执行语句例子：
some_var = 5
if some_var > 5:
print("some_var 大于 5")
elif some_var < 5:
print("some_var 小于 5")
else:
print("some_var 等于 5")循环语句
循环语句有两种，一种是 for ... in ... 的形式：
for 元素 in 范围:
执行语句例：
# 遍历数字
# range(x) 函数，可以生成一个从 0 到 x-1 的整数序列
# range(a, b) 函数，可以生成一个从 a 到 b-1 的左闭右开整数序列
# range(a, b, g) 函数，可以生成一个从 a 到 b-1 的左闭右开整数序列，每次间隔为 g，例：range(0, 10, 2)，意为从 0 到 10（不取10），每次间隔为 2
for i in range(3):
print(i)
""" （多行注释）
0
1
2
"""
# 遍历字典
dict = {"a": "A", "b": "B", "c": "C"}
for i in dict:
print(i)
"""
a
b
c
"""
# 遍历元祖
for i in (3, 4):
print(i)
"""
3
4
"""
# 遍历列表
for i, value in enumerate(["hello", "world"]):
print(i, value)
"""
0 hello
1 world
"""while 语句：
x = 0
while x < 4:
print(x)
x += 1
"""
0
1
2
3
"""函数
函数的概念不多做解释，下面是 Python 的函数写法：
def 函数名(参数1, 参数2...参数n):
函数体
return 语句
例：
# 参数可以设置默认值
def sum(x, y = 1):
s = x + y
return s
sum(2) # 3
sum(2, 3) # 5
# 使用 *args 表示不定长参数，类似 JavaScript 里的 ...rest 参数，区别是 args 的类型是一个元祖，而 rest 是一个数组。
def varargs(*args):
return args
varargs(1, 2, 3) # (1, 2, 3)
# 一般约定函数名使用下划线命名法
# 使用 **keyargs 表示可变长参数
def keyword_args(**keyargs):
return keyargs
keyword_args(a = 3, b = 4) # {"a": 3, "b": 4}
# 返回多个参数
def swap(x, y)
return y, x
a = 1
b = 2
b, a = swap(a, b)在 Python 中也可以写匿名函数：
(lambda x: x > 2)(3) # True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # 5
# 内置高阶函数
list(map(max, [1, 2, 3], [4, 2, 1])) # [4, 2, 3]
list(filter(lambda x: x > 5, [3, 4, 8, 9])) # [8, 9]类
类的定义和调用
类是一系列变量和方法的集合包，Python 中的类写法如下：
# 一般约定类名首字母大写，且使用驼峰式命名
class Human:
# 静态属性
species = "newbee"
# 构造函数，self类似 JavaScript 里的 this
def __init__(self, name):
self.name = name
# 初始化属性
self._age = 0
# 析构函数，当实例被销毁时调用
def __del__(self):
print("实例被销毁了")
# 类的实例方法，第一个参数为 this 上下文（JS语境下）
def say(self, msg):
print("{name}: {message}".format(name=self.name, message=msg))
# 类的实例方法，第一个参数为类本身
@classmethod
def get_species(cls):
return cls.species
# 类的静态方法
@staticmethod
def grunt():
return "grunt"
# 类似 getter 的属性定义
@property
def age(self):
return self._age
# 属性的 setter 方法
@age.setter
def age(self, age):
self._age = age
# 设置 deleter 允许该属性被删除
@age.deleter
def age(self):
del self._age
# 此处 __name__ 是一个系统变量，可以用来检查一个模块是否为主程序模块
if __name__ == "__main__":
# 实例化 Human 类
i = Human(name = "chen")
j = Human("liu")
i.say("hi") # "chen: hi"
j.say("hi") # "liu: hi"
# 调用类实例方法
i.say(i.get_species()) # "chen: newbee"
Human.species = "big newbee"
i.say(i.get_species()) # "chen: big newbee"
# 调用静态方法
print(Human.grunt()) # "grunt"
# 实例也可以调用静态方法
print(i.grunt()) # "grunt"
# 修改属性
i.age = 26
i.say(i.age) # "chen: 26"
j.say(j.age) # "liu: 0"
# 删除属性
del i.age类的继承
Python 中所有的类都是继承自 object 类，所以上面例子中的 Human 类也可以写成下面的写法：
class Human(object):
...继承 Human 类：
class Man(Human):
# 子类可以覆盖父类的属性
species = "Man"
def __init__(self, name, age):
self._age = age
# 调用父类的构造函数
super().__init__(name)
# 覆盖父类的 say 方法
def say(self):
print("I am a man!")
# 自定义子类的方法
def code(self):
print("I am coding!")Python 支持多继承，方法在父类中未找到时，从左至右查找父类中是否包含方法。
class Woman(Human):
species = "Woman"
def __init__(self, name, age):
self._age = age
super().__init__(name)
def birth(self):
print("new child()")
# 多继承
class Ladyman(Man, Woman):
species = "Ladyman"
def __init__(self, name, age):
self._age = age
super().__init__(name)
def birth(self):
print("sos")类型判断
使用 isinstance() 方法判断子类类型：
if __name__ == "__main__":
person1 = Human("God")
person2 = Man("Adam")
person3 = Woman("Eve")
print(isinstance(person1, Human)) # True
print(isinstance(person2, Human)) # True
print(isinstance(person1, Man)) # True
print(isinstance(person1, Woman)) # False
# isinstance() 也可用于判断基本类型
print(isinstance("000", str)) # True
print(isinstance(121, int)) # True
print(isinstance(121, str)) # False模块与标准库
模块
在 Python 中，一个 .py 文件就称之为一个模块（module）。
使用 import 关键字导入模块，如：
# 导入 math 标准库
import math
print(math.pi) # 3.141592653589793
import 默认导入该模块下所有属性和方法，类似 JavaScript 中：
import math from 'math.js'我们知道在 JavaScript 中可以导入部分方法，在 Python 中同样可以：
from math import ceil, floor
print(ceil(3.7)) # 4.0
print(floor(3.7)) # 3.0修改模块别名：
import math as m
math.sqrt(16) == m.sqrt(16) # True腾讯云开发者
