Python 极简教程：最快上手 Python 编程!

引言

Python 是由吉多·范罗苏姆(Guido Van Rossum)在 90 年代早期设计。它是如今最常用的编程语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。从之前我们的 Rust 极简教程中，我们知道 Learn X in Y minutes 是一个非常棒的编程教程网站，旨在提供快速、简洁的编程语言入门指南。本次主要分享 Python 的极简教程。

Python 的教程

# 用井字符开头的是单行注释

""" 多行字符串用三个引号
包裹，也常被用来做多
行注释
"""

####################################################
## 1. 原始数据类型和运算符
####################################################

# 整数
3# => 3

# 算术没有什么出乎意料的
1+1# => 2
8-1# => 7
10*2# => 20

# 但是除法例外，会自动转换成浮点数
35/5# => 7.0
10.0/3# => 3.3333333333333335

# 整数除法的结果都是向下取整
5//3# => 1
5.0//3.0# => 1.0 # 浮点数也可以
-5//3# => -2
-5.0//3.0# => -2.0

# 浮点数的运算结果也是浮点数
3*2.0# => 6.0

# 模除
7%3# => 1
# i % j 结果的正负符号会和 j 相同，而不是和 i 相同
-7%3# => 2

# x 的 y 次方
2**4# => 16

# 用括号决定优先级
1+3*2# => 7
(1+3) *2# => 8

# 布尔值 (注意: 首字母大写)
True# => True
False# => False

# 用 not 取非
notTrue# => False
notFalse# => True

# 逻辑运算符，注意 and 和 or 都是小写
TrueandFalse# => False
FalseorTrue# => True

# True 和 False 实质上就是数字 1 和0
True+True# => 2
True*8# => 8
False-5# => -5

# 数值与 True 和 False 之间的比较运算
0==False# => True
2==True# => False
1==True# => True
-5!=False# => True

# 使用布尔逻辑运算符对数字类型的值进行运算时，会把数值强制转换为布尔值进行运算
# 但计算结果会返回它们的强制转换前的值
# 注意不要把 bool(ints) 与位运算的 "按位与"、"按位或" (&, |) 混淆
bool(0)# => False
bool(4)# => True
bool(-6)# => True
0and2# => 0
-5or0# => -5

# 用==判断相等
1==1# => True
2==1# => False

# 用!=判断不等
1!=1# => False
2!=1# => True

# 比较大小
1<10# => True
1>10# => False
2<=2# => True
2>=2# => True

# 判断一个值是否在范围里
1<2and2<3# => True
2<3and3<2# => False
# 大小比较可以连起来！
1<2<3# => True
2<3<2# => False

# (is 对比 ==) is 判断两个变量是否引用同一个对象,
# 而 == 判断两个对象是否含有相同的值
a = [1,2,3,4]# 变量 a 是一个新的列表, [1, 2, 3, 4]
b = a# 变量 b 赋值了变量 a 的值
bisa# => True, a 和 b 引用的是同一个对象
b == a# => True, a 和 b 的对象的值相同
b = [1,2,3,4]# 变量 b 赋值了一个新的列表, [1, 2, 3, 4]
bisa# => False, a 和 b 引用的不是同一个对象
b == a# => True, a 和 b 的对象的值相同


# 创建字符串可以使用单引号（'）或者双引号（"）
"这是个字符串"
'这也是个字符串'

# 字符串可以使用加号连接成新的字符串
"Hello "+"world!"# => "Hello world!"
# 非变量形式的字符串甚至可以在没有加号的情况下连接
"Hello ""world!"# => "Hello world!"

# 字符串可以被当作字符列表
"Hello world!"[0]# => 'H'

# 你可以获得字符串的长度
len("This is a string")# => 16

# 你可以使用 f-strings 格式化字符串（python3.6+）
name ="Reiko"
f"She said her name is{name}."# => "She said her name is Reiko"
# 你可以在大括号内几乎加入任何 python 表达式，表达式的结果会以字符串的形式返回
f"{name}is{len(name)}characters long."# => "Reiko is 5 characters long."

# 用 .format 来格式化字符串
"{} can be {}".format("strings","interpolated")
# 可以重复参数以节省时间
"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack","candle stick")
# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
# 如果不想数参数，可以用关键字
"{name} wants to eat {food}".format(name="Bob", food="lasagna")
# => "Bob wants to eat lasagna"

# 如果你的 Python3 程序也要在 Python2.5 以下环境运行，也可以用老式的格式化语法
"%s can be %s the %s way"% ("strings","interpolated","old")

# None是一个对象
None# => None

# 当与 None 进行比较时不要用 ==，要用 is。is 是用来比较两个变量是否指向同一个对象。
"etc"isNone# => False
NoneisNone# => True

# None，0，空字符串，空列表，空字典，空元组都算是 False
# 所有其他值都是 True
bool(0)# => False
bool("")# => False
bool([])# => False
bool({})# => False
bool(())# => False


####################################################
## 2. 变量和集合
####################################################

# print是内置的打印函数
print("I'm Python. Nice to meet you!")

# 默认情况下，print 函数会在输出结果后加入一个空行作为结尾
# 可以使用附加参数改变输出结尾
print("Hello, World", end="!")# => Hello, World!

# 可以很简单的从终端获得输入数据
input_string_var = input("Enter some data: ")# 返回字符串数值

# 在给变量赋值前不用提前声明
# 习惯上变量命名是小写，用下划线分隔单词
some_var =5
some_var# => 5

# 访问未赋值的变量会抛出异常
# 参考流程控制一段来学习异常处理
some_unknown_var# 抛出 NameError

# "if" 可以用作表达式，它的作用等同于 C 语言的三元运算符 "?:"
"yay!"if0>1else"nay!"# => "nay!"

# 用列表 (list) 储存序列
li = []
# 创建列表时也可以同时赋给元素
other_li = [4,5,6]

# 用append在列表最后追加元素
li.append(1)# li现在是[1]
li.append(2)# li现在是[1, 2]
li.append(4)# li现在是[1, 2, 4]
li.append(3)# li现在是[1, 2, 4, 3]
# 用pop从列表尾部删除
li.pop()# => 3 且li现在是[1, 2, 4]
# 把3再放回去
li.append(3)# li变回[1, 2, 4, 3]

# 列表存取跟数组一样
li[0]# => 1
# 取出最后一个元素
li[-1]# => 3

# 越界存取会造成 IndexError
li[4]# 抛出 IndexError

# 列表有切割语法
li[1:3]# => [2, 4]
# 取尾
li[2:]# => [4, 3]
# 取头
li[:3]# => [1, 2, 4]
# 隔一个取一个
li[::2]# =>[1, 4]
# 倒排列表
li[::-1]# => [3, 4, 2, 1]
# 可以用三个参数的任何组合来构建切割
# li[始:终:步伐]

# 简单的实现了单层数组的深度复制
li2 = li[:]# => li2 = [1, 2, 4, 3] ，但 (li2 is li) 会返回 False

# 用 del 删除任何一个元素
delli[2]# li 现在为 [1, 2, 3]

# 删除第一个匹配的元素
li.remove(2)# li 现在为 [1, 3]
li.remove(2)# 抛出错误 ValueError: 2 is not in the list

# 在指定索引处插入一个新的元素
li.insert(1,2)# li is now [1, 2, 3] again

# 获得列表第一个匹配的值的索引
li.index(2)# => 1
li.index(4)# 抛出一个 ValueError: 4 is not in the list

# 列表可以相加
# 注意：li 和 other_li 的值都不变
li + other_li# => [1, 2, 3, 4, 5, 6]

# 用 "extend()" 拼接列表
li.extend(other_li)# li 现在是[1, 2, 3, 4, 5, 6]

# 用 "in" 测试列表是否包含值
1inli# => True

# 用 "len()" 取列表长度
len(li)# => 6


# 元组类似列表，但是不允许修改
tup = (1,2,3)
tup[0]# => 1
tup[0] =3# 抛出 TypeError

# 如果元素数量为 1 的元组必须在元素之后加一个逗号
# 其他元素数量的元组，包括空元组，都不需要
type((1))# => <class 'int'>
type((1,))# => <class 'tuple'>
type(())# => <class 'tuple'>

# 列表允许的操作元组大多都可以
len(tup)# => 3
tup + (4,5,6)# => (1, 2, 3, 4, 5, 6)
tup[:2]# => (1, 2)
2intup# => True

# 可以把元组合列表解包，赋值给变量
a, b, c = (1,2,3)# 现在 a 是 1，b 是 2，c 是 3
# 也可以做扩展解包
a, *b, c = (1,2,3,4)# 现在 a 是 1, b 是 [2, 3]， c 是 4
# 元组周围的括号是可以省略的
d, e, f =4,5,6# 元组 4, 5, 6 通过解包被赋值给变量 d, e, f
# 交换两个变量的值就这么简单
e, d = d, e# 现在 d 是 5，e 是 4


# 字典用来存储 key 到 value 的映射关系
empty_dict = {}
# 初始化的字典
filled_dict = {"one":1,"two":2,"three":3}

# 字典的 key 必须为不可变类型。 这是为了确保 key 被转换为唯一的哈希值以用于快速查询
# 不可变类型包括整数、浮点、字符串、元组
invalid_dict = {[1,2,3]:"123"}# => 抛出 TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}# 然而 value 可以是任何类型

# 用[]取值
filled_dict["one"]# => 1

# 用 keys 获得所有的键。
# 因为 keys 返回一个可迭代对象，所以我们需要把它包在 "list()" 里才能转换为列表。
# 我们下面会详细介绍可迭代。
# 注意: 对于版本 < 3.7 的 python, 字典的 key 的排序是无序的。你的运行结果
# 可能与下面的例子不符，但是在 3.7 版本，字典中的项会按照他们被插入到字典的顺序进行排序
list(filled_dict.keys())# => ["three", "two", "one"] Python 版本 <3.7
list(filled_dict.keys())# => ["one", "two", "three"] Python 版本 3.7+

# 用 "values()" 获得所有的值。跟 keys 一样也是可迭代对象，要使用 "list()" 才能转换为列表。
# 注意: 排序顺序和 keys 的情况相同。

list(filled_dict.values())# => [3, 2, 1] Python 版本 < 3.7
list(filled_dict.values())# => [1, 2, 3] Python 版本 3.7+


# 用in测试一个字典是否包含一个键
"one"infilled_dict# => True
1infilled_dict# => False

# 访问不存在的键会导致 KeyError
filled_dict["four"]# KeyError

# 用 "get()" 来避免KeyError
filled_dict.get("one")# => 1
filled_dict.get("four")# => None
# 当键不存在的时候 "get()" 方法可以返回默认值
filled_dict.get("one",4)# => 1
filled_dict.get("four",4)# => 4

# "setdefault()" 方法只有当键不存在的时候插入新值
filled_dict.setdefault("five",5)# filled_dict["five"] 设为5
filled_dict.setdefault("five",6)# filled_dict["five"] 还是5

# 字典赋值
filled_dict.update({"four":4})# => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] =4# 另一种赋值方法

# 用 del 删除项
delfilled_dict["one"]# 从 filled_dict 中把 one 删除


# 用 set 表达集合
empty_set = set()
# 初始化一个集合，语法跟字典相似。
some_set = {1,1,2,2,3,4}# some_set现在是 {1, 2, 3, 4}

# 类似字典的 keys，set 的元素也必须是不可变类型
invalid_set = {[1],1}# => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,),1}

# 可以把集合赋值于变量
filled_set = some_set

# 为集合添加元素
filled_set.add(5)# filled_set 现在是 {1, 2, 3, 4, 5}
# set 没有重复的元素
filled_set.add(5)# filled_set 依然是 {1, 2, 3, 4, 5}

# "&" 取交集
other_set = {3,4,5,6}
filled_set & other_set# => {3, 4, 5}

# "|" 取并集
filled_set | other_set# => {1, 2, 3, 4, 5, 6}

# "-" 取补集
{1,2,3,4} - {2,3,5}# => {1, 4}

# "^" 取异或集（对称差）
{1,2,3,4} ^ {2,3,5}# => {1, 4, 5}

# 判断左边的集合是否是右边集合的超集
{1,2} >= {1,2,3}# => False

# 判断左边的集合是否是右边集合的子集
{1,2} <= {1,2,3}# => True

# in 测试集合是否包含元素
2infilled_set# => True
10infilled_set# => False

# 单层集合的深度复制
filled_set = some_set.copy()# filled_set 是 {1, 2, 3, 4, 5}
filled_setissome_set# => False

####################################################
## 3. 流程控制和迭代器
####################################################

# 先随便定义一个变量
some_var =5

# 这是个if语句。注意缩进在Python里是有意义的！
# 缩进要使用 4 个空格而不是 tabs。
# 这段代码会打印 "some_var is smaller than 10"
ifsome_var >10:
print("some_var is totally bigger than 10.")
elifsome_var <10:# elif 语句是可选的
print("some_var is smaller than 10.")
else:# else 也是可选的
print("some_var is indeed 10.")


"""
用 for 循环语句遍历列表
打印:
dog is a mammal
cat is a mammal
mouse is a mammal
"""
foranimalin["dog","cat","mouse"]:
# 你可以使用 format() 格式化字符串并插入值
print("{} is a mammal".format(animal))

"""
"range(number)" 返回数字列表从 0 到 number 的数字
打印:
0
1
2
3
"""
foriinrange(4):
print(i)

"""
"range(lower, upper)" 会返回一个包含从 lower 到 upper 的数字迭代器
prints:
4
5
6
7
"""
foriinrange(4,8):
print(i)

"""
"range(lower, upper, step)" 会返回一个，从 lower 到 upper、并且间隔值为 step 的迭代器。
如果 step 未传入则会使用默认值 1
prints:
4
6
"""
foriinrange(4,8,2):
print(i)

"""
遍历列表，并且同时返回列表里的每一个元素的索引和数值。
prints:
0 dog
1 cat
2 mouse
"""
animals = ["dog","cat","mouse"]
fori, valueinenumerate(animals):
print(i, value)

"""
while 循环直到条件不满足
打印:
0
1
2
3
"""
x =0
whilex <4:
print(x)
x +=1# x = x + 1 的简写


# 用 try/except 块处理异常状况
try:
# 用 raise 抛出异常
raiseIndexError("This is an index error")
exceptIndexErrorase:
pass# pass 是无操作，但是应该在这里处理错误
except(TypeError, NameError):
pass# 可以同时处理不同类的错误
else:# else语句是可选的，必须在所有的except之后
print("All good!")# 只有当try运行完没有错误的时候这句才会运行
finally:# 在任何情况下都会执行
print("We can clean up resources here")

# 你可以使用 with 语句来代替 try/finally 对操作进行结束的操作
withopen("myfile.txt")asf:
forlineinf:
print(line)

# 写入文件
contents = {"aa":12,"bb":21}
withopen("myfile1.txt","w+")asfile:
file.write(str(contents))# 写入字符串到文件

withopen("myfile2.txt","w+")asfile:
file.write(json.dumps(contents))# 写入对象到文件

# Reading from a file
withopen("myfile1.txt","r+")asfile:
contents = file.read()# 从文件读取字符串
print(contents)
# print: {"aa": 12, "bb": 21}

withopen("myfile2.txt","r+")asfile:
contents = json.load(file)# 从文件读取 json 对象
print(contents)
# print: {"aa": 12, "bb": 21}

# Windows 环境调用 open() 读取文件的默认编码为 ANSI，如果需要读取 utf-8 编码的文件，
# 需要指定 encoding 参数:
# open("myfile3.txt", "r+", encoding = "utf-8")


# Python 提供一个叫做可迭代 (iterable) 的基本抽象。一个可迭代对象是可以被当作序列
# 的对象。比如说上面 range 返回的对象就是可迭代的。

filled_dict = {"one":1,"two":2,"three":3}
our_iterable = filled_dict.keys()
print(our_iterable)# => dict_keys(['one', 'two', 'three'])，是一个实现可迭代接口的对象

# 可迭代对象可以遍历
foriinour_iterable:
print(i)# 打印 one, two, three

# 但是不可以随机访问
our_iterable[1]# 抛出TypeError

# 可迭代对象知道怎么生成迭代器
our_iterator = iter(our_iterable)

# 迭代器是一个可以记住遍历的位置的对象
# 用 "next()" 获得下一个对象
next(our_iterator)# => "one"

# 再一次调取 "next()" 时会记得位置
next(our_iterator)# => "two"
next(our_iterator)# => "three"

# 当迭代器所有元素都取出后，会抛出 StopIteration
next(our_iterator)# 抛出 StopIteration

# 我们还可以通过遍历访问所有的值，实际上，for 内部实现了迭代
our_iterator = iter(our_iterable)
foriinour_iterator:
print(i)# 依次打印 one, two, three

# 可以用 list 一次取出迭代器或者可迭代对象所有的元素
list(filled_dict.keys())# => 返回 ["one", "two", "three"]
list(our_iterator)# => 返回 [] 因为迭代的位置被保存了


####################################################
## 4. 函数
####################################################

# 用def定义新函数
defadd(x, y):
print("x is {} and y is {}".format(x, y))
returnx + y# 用 return 语句返回

# 调用函数
add(5,6)# => 打印 "x is 5 and y is 6" 并且返回 11

# 也可以用关键字参数来调用函数
add(y=6, x=5)
						
继续阅读与本文标签相同的文章
						

														无标签