[教程] 在 Y 分钟内学会 Python
Posted 诺尔Null
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[教程] 在 Y 分钟内学会 Python相关的知识，希望对你有一定的参考价值。
在 Y 分钟内学会 Python
这是翻译, 原文地址: Learn Python in Y Minutes
在 90 年代初, Python 由 Guido van Rossum 创造, 现在, 它是最受欢迎的编程语言之一. 因其简明的语法, 我爱上了它. 语法基本上是可以执行的伪代码.
提示: 这篇文章适用于 Python 3, 如果你想要学习旧版 Python 2.7, 单击这里
# 单行注释以 '#' 作为开头
"""多行注释可以使用三个双引号
并且经常用与书写文档
"""
####################################################
## 1. 原始数据类型和操作符
####################################################
# 你可以使用数字
3 # 等同于 3
# 数学运算也是你希望使用的形式
1 + 1 # 结果是 2
8 - 1 # 结果是 7
10 * 2 # 结果是 20
35 / 5 # 结果是 7.0
# 正负数的整除都会向下取整
5 // 3 # 结果是 1
-5 // 3 # 结果是 -2
5.0 // 3.0 # 结果是 1.0 # 在浮点运算中也同样生效
-5.0 // 3.0 # 结果是 -2.0
# 除法的运算结果始终是浮点数
10.0 / 3 # 结果是 3.3333333333333335
# 取模运算
7 % 3 # 结果是 1
# i % j 结果的符号与 j 相同, 这与 C 语言不同
-7 % 3 # 结果是 2
# 幂运算 (x**y, x的y次方)
2 ** 3 # 结果是 8
# 用括号来强制优先运算
1 + 3 * 2 # 结果是 7
(1 + 3) * 2 # 结果是 8
# 布尔值是基本数据类型
True # 值为 真(true)
False # 值为 假(false)
# 使用 not 来进行非运算
not True # 结果是 假
not False # 结果是 真
# 布尔值操作符:
# 提示, 'and' 和 'or' 是区分大小写的
True and False # 结果是 假
False or True # 结果是 真
# True 和 False 事实上也等同于 1 和 0, 只不过是使用了不同的关键字
True + True # 结果是 2
True * 8 # 结果是 8
False - 5 # 结果是 -5
# 比较运算符会检查 True 和 False 的数字值
0 == False # 结果是 真
1 == True # 结果是 真
2 == True # 结果是 假
-5 != False # 结果是 真
# 对整数使用布尔逻辑操作符, 则会将它们转换为布尔值以求值，但返回未转换的值
# 不要把 bool(ints) 和 位运算 and/or 搞混了
bool(0) # 返回 假
bool(4) # 返回 真
bool(-6) # 返回 真
0 and 2 # 返回 0
-5 or 0 # 返回 -5
# 运算符 '等同于' 是 ==
1 == 1 # 返回 真
2 == 1 # 返回 假
# 运算符 '不等于' 是 !=
1 != 1 # 返回 假
2 != 1 # 返回 真
# 更多比较运算符
1 < 10 # 返回 真
1 > 10 # 返回 假
2 <= 2 # 返回真
2 >= 2 # 返回真
# 检查一个值是否在指定范围内
1 < 2 and 2 < 3 # 返回 真
1 < 3 and 3 < 2 # 返回 假
# 连接起来, 这样看起来会更好看些
1 < 2 < 3 # 返回 真
2 < 3 < 2 # 返回 假
# (is 与 ==) is 将会检查两个变量是否引用了同一个对象, 但是 == 检查
# 两个对象是否指向了相同的值
a = [1, 2, 3, 4] # 使 a 指向一个新的列表, [1, 2, 3, 4]
b = a # 使 b 指向 a 所指向的对象
b is a # 返回 真, a 和 b 引用的是同一个对象
b == a # 返回 真, a 和 b 的对象是相等的
b = [1, 2, 3, 4] # 使 b 指向一个新的列表, [1, 2, 3, 4]
b is a # 返回 假, a 与 b 并不引用同一个对象
b == a # 返回 真, a 和 b 的对象使相等的
# 字符串可以使用 双引号 " 或 单引号 ' 来创建
"这是一个字符串"
'这也是一个字符串'
# 字符串可以相加
"Hello " + "world!" # 返回 "Hello world!"
"Hello " "world!" # 等同于 "Hello world!"
# 字符串可以用作一个字符列表
"Hello world!"[0] # 返回 'H'
# 你可以获取字符串的长度:
len("这是一个字符串") # 返回 7
# 你可以使用 f-字符串 或 格式化字符串 来对字符串文本进行格式化 (在 Python 3.6 或更高版本)
name = "小红"
f"她说她的名字是{name}." # 返回 "她说她的名字是小红."
# 你可以基本的将 Python 表达式放到括号内, 然后它就会被输出到字符串中.
f"{name}是{len(name)}字符长." # 返回 "小红是两个字符长"
# None 是一个对象
None # 返回 None
# 不要使用等同于运算符 '==' 来比较对象和 None
# 使用 'is' 来代替. 这个会检查对象标识是否相同.
"etc" is None # 返回 假
None is None # 返回 真
# None, 0, 以及空的字符串/列表/字典/元组, 都计算为 假
bool(0) # => 假
bool('') # => 假
bool([]) # => 假
bool({}) # => 假
bool(()) # => 假
####################################################
## 2. 变量和集合
####################################################
# Python 有一个 print 函数, 用于标准输出
print("我是Python, 很高兴见到你!") # => 我是Python, 很高兴见到你!
# 默认的, print 函数还会在结尾输出一个换行符
# 使用可选参数 'end' 来改变末尾的字符串.
print("Hello, world", end="!") # => Hello, world! # 输出后没有换行
# 从控制台获取输入数据的简单方式:
input_string_var = input("Enter some data:") # 以字符串的形式返回输入数据
# Python 中没有变量的声明, 只有赋值.
# 命名规范是使用小写以及下划线, 就像这样: lower_case_with_underscores
some_var = 5
some_var # => 5
# 访问一个没有生命的变量是错误的
# 查看控制流来获取更多异常捕捉信息
some_unknown_var # 这是一个一个未定义的变量, 运行时将抛出 NameError 异常
# if 也可用作一个表达式
# 等同于 C 语言中的 '?:' 三元运算符
"yay" if 0 > 1 else "nay!" # => "nay"
# 列表可以存储一个序列, 可以这样定义:
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]
# 重新将它放回去
li.append(3) # 现在 li 又变成 [1, 2, 4, 3] 了
# 像访问数组一样访问一个列表
li[0] # => 1
# 访问列表的最后一个元素
li[-1] # => 3
# 如果索引超出界限, 那么会抛出 IndexError 异常
li[4] # 抛出 IndexError 异常
# 你可以使用切片语法来查看一个范围内的元素
# 起始索引包含在内, 但结束索引不包含在内
# (对于数学类型来讲, 它是一个 闭/开 区间)
li[1:3] # 返回从索引1到3的一个列表 => [2, 4]
li[2:] # 返回从索引2开始的列表 => [4, 3]
li[:3] # 返回从开始到索引3的列表 => [1, 2, 4]
li[::2] # 返回一个每两个元素选择一个的列表 => [1, 4]
li[::-1] # 返回反向排列的列表 => [3, 4, 2, 1]
# 使用任意组合来实现高级切片
# li[起始:结束:步长]
# 使用切片来创建一个单层的深度拷贝
li2 = li[:]
# 使用 "del" 来删除任意元素
del li[2] # 现在 li 的值是 [1, 2, 3]
# 删除第一个匹配值的元素
li.remove(2) # 现在 li 的值是 [1, 3]
li.remove(2) # 抛出 ValueError 异常, 2 并不在这个列表中
# 在指定索引处插入元素, 列表.insert(索引, 元素)
li.insert(1, 2) # 现在 li 的值又是 [1, 2, 3] 了
# 获取第一个匹配元素的索引
li.index(2) # => 1
li.index(4) # 抛出 ValueError 异常, 4 不在这个列表中
# 你可以将列表相加
# 提示: values 和 other_li 的值不会被修改
li + other_li # => [1, 2, 3, 4, 5, 6]
# 使用 "extend()" 连接列表, extend 的意思是拓展
li.extend(other_li) # 现在 li 的值是 [1, 2, 3, 4, 5, 6]
# 使用 "in" 检查元素是否存在于列表中
1 in li # => True
# 使用 "len()" 检查列表的长度
len(li) # => 6
# 元组与列表相像, 但是不可更改
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # 抛出一个 TypeError
# 提示, 长度为一的元组的最后一个元素必须有一个逗号跟随, 但是
# 其他长度的元组, 尽管是0, 也不需要
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)
2 in tup # => 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
# 变量值分别如下: d = 4, e = 5 以及 f = 6
# 那么看看交换两个值是多么的简单
e, d = d, e
# 字典用于存储从键到值的映射
empty_dict = {} # 创建了一个空字典
# 下面是一个带有初始值的字典
filled_dict = {"one": 1, "two": 2, "three": 3}
# 提示: 字典的键必须是不可变的类型. 这是为了确保
# 键能够转换为用于快速查询的常量哈希值.
# 不可变类型包含整数, 浮点数, 字符串, 元组
invalid_dict = {[1, 2, 3]: "123"} # 抛出 TypeError: unhashable type: 'list' 异常. (类型错误: 无法进行哈希化的类型: '列表')
valid_dict = {(1, 2, 3): [1, 2, 3]} # 然而, 值可以是任何类型
# 使用 [] 来查询值
filled_dict["one"] # => 1
# 使用 "keys()" 来获取所有的键并作为一个可迭代对象返回. 我们需要在 list() 中将调用结果转换
# 为一个列表. 这个稍后再讲. 提示 - 在 Python 低于 3.7 的版本中
# 字典键索引的顺序是无法保证的. 你的结果可能不与下面的例子完全相等. 然而, 在 Python 3.7 中, 字典
# 元素会保持它们被插入到字典的顺序
list(filled_dict.keys()) # => ["three", "two", "one"] 在低于 3.7 的 Python 版本中
list(filled_dict.keys()) # => ["one", "two", "three"] 在 3.7 或更高的 Python 版本中
# 使用 "values()" 来获取所有的值并作为可迭代对象返回. 同样, 我们需要将其在
# list() 中转换, 以取出这个可迭代对象的值. 提示 - 和上面键的顺序是一样的
list(filled_dict.values()) # => [3, 2, 1] 在低于 3.7 的 Python 版本中
list(filled_dict.values()) # => [1, 2, 3] 在 3.7 或更高的 Python 版本中
# 使用 "in" 来检查键是否在字典中
"one" in filled_dict # => True
1 in filled_dict # => False
# 通过不存在的键来查找字典, 会抛出 KeyError 异常
filled_dict["four"] # KeyError
# 使用 "get()" 方法来避免 KeyError 异常
filled_dict.get("one") # => 1
filled_dict.get("four") # => None
# 这个方法支持当找不到值时返回指定的默认值
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 # 向字典中添加的另一种方式
# 自 Python 3.5 以来, 你还可以使用拓展解包选项
{'a': 1, **{'b': 2}} # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}} # => {'a': 2}
# 集合用来存储 ... 额, 集合
empty_set = set() # 空集合
# 用一组值来初始化一个集合, 嗯, 看起来有点像字典, 抱歉
some_set = {1, 1, 2, 2, 3, 4} # some_set 现在的值是 {1, 2, 3, 4}
# 与字典中的键相似, 集合的元素必须是不可变的
invalid_set = {[1], 1} # => 抛出一个 TypeError: unhashable type: 'list' (类型错误: 无法进行哈希化的类型: '列表')
valid_set = {(1,), 1}
# 向集合中添加一个或多个条目
filled_set = some_set
filled_set.add(5) # filled_set 现在是 {1, 2, 3, 4, 5}
# 集合是不包含重复元素的
filled_set.add(5) # 还是与之前一样 {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 来检查是否存在于集合中
2 in filled_set # => True
10 in filled_set # => False
# 生成一个单层的深层副本
filled_set = some_set.copy() # filled_set 是 {1, 2, 3, 4, 5}
filled_set is some_set # => False
####################################################
## 3. 控制流和可迭代对象
####################################################
# 首先我们声明一个变量
some_var = 5
# 这是一个 if 语句, 缩进在 Python 中非常重要
# 约定语法是使用四个空格, 而不是水平制表符(tab)
# 这个将会打印 "some_var 比 10 小"
if some_var > 10:
print("some_var 比 10 大")
elif some_var < 10: # 这个 elif 语句是可选的
print("some_var 比 10 小")
else: # 这个也是可选的
print("some_var 与 10 相等")
"""
for 语句用来循环遍历列表
将会打印:
狗是哺乳动物
猫是哺乳动物
老鼠是哺乳动物
"""
for animal in ["狗", "猫", "老鼠"]:
# 你可以使用 format() 来插入格式化字符串
print("{}是哺乳动物".format(animal))
"""
"range(数字)" 返回一个数字的可迭代对象
从0到给定数字
将会打印:
0
1
2
3
"""
for i in range(4):
print(i)
"""
"range(较小的数, 较大的数)" 返回一个数字的可迭代对象
从较小的数字到较大的数字
将会打印:
4
5
6
7
"""
for i in range(4, 8):
print(i)
"""
"range(较小的数, 较大的数, 步长)" 返回一个数字的可迭代对象
从较小的数到较大的数, 以步长未每次增长的值
如果步长没有指定, 默认值则是 1
将会打印:
4
6
"""
for i in range(4, 8, 2):
print(i)
"""
循环一个列表, 并且同时检索列表中每一个条目的索引和值
将会打印:
0 狗
1 猫
2 老鼠
"""
animals = ["狗", "猫", "老鼠"]
for i, value in enumerate(animals):
print(i, value)
"""
while 循环将一直进行到条件不再满足为止
将会打印:
0
1
2
3
"""
x = 0
while x < 4:
print(x)
x += 1 # x = x + 1 的简写
# 使用 try/except 语句块来处理异常
try:
# 使用 "raise" 来抛出异常
raise IndexError("这是一个索引错误")
except IndexError as e:
pass # pass 只是一个占位符(不进行任何操作). 通常你需要在这里对异常进行处理
except (TypeError, NameError):
pass # 如果需要, 你可以同时处理多个异常.
else: # try/except 语句块的可选语句. 必须在所有 except 语句块的后面
print("一切正常!") # 仅在 try 语句内没有任何异常时运行
finally: # 在任何情况下都会执行
print("我们可以在这里进行资源清理")
# 你可以使用 with 语句代替 try/finally 来清理资源
with open("我的文件.txt") as f:
for line in f:
print(line)
# 向文件中写入内容
contents = {"aa": 12, "bb": 21}
with open("我的文件1.txt", "w+") as file:
file.write(str(content)) # 向文件中写入字符串
with open("我的文件2.txt", "w+") as file:
file.write(json.dumps(content)) # 向文件中写入一个对象
# 从文件中读取
with open("我的文件1.txt", "r+") as file:
contents = file.read() # 从文件中读取一个字符串
print(contents)
# 打印: {"aa", 12, "bb": 21}
with open("我的文件2.txt", "r+") as file:
contents = json.load(file) # 从文件中读取一个json对象
print(contents)
# print: {"aa": 12, "bb": 21}
# Python 提供了一个叫做 Iterable(可迭代的) 的基本抽象
# 一个可迭代对象是一个可视为序列的对象
# range 函数返回的对象就是一个可迭代对象
filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable) # => dict_keys(['one', 'two', 'three']). 这是一个实现了 Iterable 接口的对象
# 我们可以检索它
for i in our_iterable:
print(i) # 打印 one, two, three
# 然而, 我们不可以通过索引来找到元素
our_iterable[1] # 抛出 TypeError 异常
# 一个可迭代对象即为能够创以上是关于[教程] 在 Y 分钟内学会 Python的主要内容，如果未能解决你的问题，请参考以下文章