Python极简教程 on 重定向学院

python简明教程: 1. 基本数据类型及操作

Thu, 22 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


# 以```#```开头进行单行注释

""" 使用3个双引号
 来定义多行文本
 多行文本一般被用来
 做注释用了
"""

# 这是数字
3 # => 3

# 这是做简单的算术
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7

# 除法有点不太一样，除法默认是做整数除法，比如
5 / 2 # => 2

# 我们一般所认知的除法在python里其实就是浮点数除法，嗯，首先要了解什么是浮点数(floats)
2.0 # 这就是浮点数了
11.0 / 4.0 # => 2.75 嗯...好多了

# 可以强制返回整数，正数负数都可以了
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # 浮点数也行
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0

# 注意，我们可以可以import division 模块(关于import教程第6节会有涉及)
# 这样 '/' 就可以实现普通的我们所熟悉的除法功能了
# 貌似python3里面'/'默认就是普通除法模式
from __future__ import division

11 / 4 # => 2.75 ...普通除法
11 // 4 # => 2 ...取整除法

# 模/取余操作
7 % 3 # => 1

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

# 用括号强制改变算术的结合律
(1 + 3) * 2 # => 8

# 布尔值的操作或者叫逻辑运算
# 注意 "and" 和 "or" 是区分大小写的
True and False # => False
False or True # => True

# 注意布尔操作跟整数搅在一起的时候
0 and 2 # => 0
-5 or 0 # => -5
0 == False # => True
2 == True # => False
1 == True # => True

# 用not来逻辑取反
not True # => False
not False # => True

# 相等判断用 ==
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 < 2 < 3 # => True
2 < 3 < 2 # => False

# 用 " 或 ' 来创建字符串
"This is a string."
'This is also a string.'

# 字符串也是可以相加的!
"Hello " + "world!" # => "Hello world!"
# 不用 '+' 号也能加
"Hello " "world!" # => "Hello world!"

# ... 甚至可以相乘
"Hello" * 3 # => "HelloHelloHello"

# 字符串可以当成是字符组成的列表
"This is a string"[0] # => 'T'

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

# 可以用 % 来格式化字符串
# Even though the % string operator will be deprecated on Python 3.1 and removed
# 即使 % 操作在Python 3.1以后会被废弃和移除
# 不过知道这些代码是如何工作的总不是坏事
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s" % (x, y)

# 新一点的格式化字符串的方式是使用format方法
# 这个方法更好一些
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")
# 如果你不想数数的话，你还可以使用关键字
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

# None是一个对象
# 所以你是有对象的
None # => None

# 不要使用 "==" 符号进行对象和None的比较
# 要使用 "is"
"etc" is None # => False
None is None # => True

# 'is'符号用来测试对象的之间的相当性
# 在比较基本类型的时候可能用处不大
# 不过用在对象的比较方面却是很有用的

# Any object can be used in a Boolean context.
# 任何的对象都可以在布尔值的上下文中使用
# 下面的值会被认为是false的
# - None
# - zero of any numeric type (e.g., 0, 0L, 0.0, 0j)
# - 任何数字类型的0 (比如, 0, 0L, 0.0, 0j)
# - 空序列 (比如, '', (), [])
# - 空的容器类型 (比如, {}, set())
# - 某些情况下用户自定义的类的实例
# 见: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# 其他的值都被认为是true(使用bool()测试这些值的时候会返回True).
bool(0) # => False
bool("") # => False

原始封面

python简明教程: 2. 变量和集合

Wed, 21 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


# Python 有 print 语句
print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!

# Python3 的时候你应该这么写
print("I'm Python. Nice to meet you!") # => I'm Python. Nice to meet you!

# 从控制台获取输入的简便方法
input_string_var = raw_input(
 "Enter some data: ") # 返回字符串
input_var = input("Enter some data: ") # 把输入作为python代码执行
# 警告: 使用input() 方法时千万请小心谨慎
# 注意: python 3里input()方法被废弃了，并且raw_input()被重命名成了input()

# 给变量赋值之前是不需要声明的
some_var = 5 # 一般约定使用下划线去给变量名分词 lower_case_with_underscores
some_var # => 5

# 访问没有定义的变量会抛出异常
# 在控制流部分可以查看更多关于异常处理的信息
some_other_var # Raises a name error

# if可以作为表达式使用
# 跟 C语言中 '?:' 三元操作符等价
"yahoo!" if 3 > 2 else 2 # => "yahoo!"


li = []
# 你可以定义一个预填充(或者叫非空的列表可能比较好)列表
other_li = [4, 5, 6]

# 使用append方法向列表的尾部添加元素
li.append(1) # li is now [1]
li.append(2) # li is now [1, 2]
li.append(4) # li is now [1, 2, 4]
li.append(3) # li is now [1, 2, 4, 3]
# 使用pop将元素从列表尾部移除
li.pop() # => 3 and li is now [1, 2, 4]
# 重新加回去
li.append(3) # li is now [1, 2, 4, 3] again.

# 访问列表元素跟访问数组元素的语法是相同的
li[0] # => 1
# 使用 = 可以给已经初始化过的索引赋新值
li[0] = 42
li[0] # => 42
li[0] = 1 # 注意: 设置回原先的值
# 访问最后1个元素
li[-1] # => 3

# 访问越界的话会抛出 IndexError
li[4] # Raises an IndexError

# 使用切片(slice)语法可以访问列表中的部分元素.
# (It's a closed/open range for you mathy types.)
li[1:3] # => [2, 4]
# 忽略开头
li[:3] # => [1, 2, 4]
# 忽略结尾
li[2:] # => [4, 3]
# 每隔2个元素选择1个
li[::2] # =>[1, 4]
# 反转列表的拷贝
li[::-1] # => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# 使用上述的各种组合来创建更加复杂的切片
# li[start:end:step]

# 使用 "del" 来删除任意元素
del li[2] # li is now [1, 2, 3]

# 列表可以相加
li + other_li # => [1, 2, 3, 4, 5, 6]
# 注意: li 和 for other_li 的值没有变化的

# 使用"extend()"来连接列表
# 注意: li的值变化了的
li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]

# 移除第一个满足条件的值
li.remove(2) # li is now [1, 3, 4, 5, 6]
li.remove(2) # 抛出ValueError, 2已经不在列表里了

# 在特定的索引(index)处插入元素
li.insert(1, 2) # li is now [1, 2, 3, 4, 5, 6] again

# 返回第1个满足条件的值的索引
li.index(2) # => 1
li.index(7) # 抛出ValueError，因为7不在列表里

# 用 "in" 来检查元素是否在列表中存在
1 in li # => True

# 用 "len()" 来返回列表的长度
len(li) # => 6

# 元组(Tuples) 跟列表很想，区别是元组是不可变的
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # 抛出TypeError异常

# 你可以在元组上做下面一些的列表操作
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
2 in tup # => True

# You can unpack tuples (or lists) into variables
# 你可以把元组(或列表) unpack成变量
a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3
d, e, f = 4, 5, 6 # 你都可以省略括号
# 如果你不加括号的话，默认情况下会创建元组
g = 4, 5, 6 # => (4, 5, 6)
# 看一下，交换变量的值那是相当容易的
e, d = d, e # d is now 5 and e is now 4

# 字典是用来存储属性名(key)和属性值(value)的
empty_dict = {}
# 这是预填充的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 用[]来查找属性的值(value)
filled_dict["one"] # => 1

# 用"keys()"来返回所有key的列表
filled_dict.keys() # => ["three", "two", "one"]
# 注意 - 字典key的顺序是不保证的
# 你自己的结果可能会跟上面不同

# "values()"返回所有值(value)的列表
filled_dict.values() # => [3, 2, 1]
# 注意 - 排序问题跟上面的类似

# "items()" 返回所有的键值对(key-value)的元组组成的列表
filled_dicts.items() # => [("one", 1), ("two", 2), ("three", 3)]

# 用"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
# get支持当属性名/键不存在的时候返回1个设定的默认值
filled_dict.get("one", 4) # => 1
filled_dict.get("four", 4) # => 4
# 注意: filled_dict.get("four") 仍然是 => None
# (get 并不会设置字典的值)

# 为某个属性名/键赋值跟列表赋值的方式差不多
filled_dict["four"] = 4 # now, filled_dict["four"] => 4

# "setdefault()" 方法在给定的属性名/键不存在的时候会插入具体的值
filled_dict.setdefault("five", 5) # filled_dict["five"] 被设置成 5
filled_dict.setdefault("five", 6) # filled_dict["five"] 仍然是 5

# 集合是存储... 好吧，集合 (跟列表差不多，只是不能有重复的项)
empty_set = set()
# 初始化的时候赋一些值
some_set = set([1, 2, 2, 3, 4]) # some_set 现在等于set([1, 2, 3, 4])

# 顺序是不被保证的, 即使有时候看起来像排过序一样
another_set = set([4, 3, 2, 2, 1]) # another_set 现在是 set([1, 2, 3, 4])

# 从Python 2.7开始, {} 可以被用来声明集合
filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}

# 往集合里添加更多项
filled_set.add(5) # filled_set is now {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

原始封面

python简明教程: 3. 控制流

Tue, 20 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 3. 控制流
####################################################

# 定义变量
some_var = 5

# 这是if语句，注意缩进，在python里缩进非常重要！
# 结果是打印 "some_var is smaller than 10"
if some_var > 10:
 print "some_var is totally bigger than 10."
elif some_var < 10: # elif 分支是可选的
 print "some_var is smaller than 10."
else: # 这也是可选的
 print "some_var is indeed 10."

"""
用for去遍历list
打印结果:
 dog is a mammal
 cat is a mammal
 mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
 # 可以用{0}语法去格式化打印，参考之前的教程
 print "{0} is a mammal".format(animal)

"""
"range(number)" 返回1个列表，列表里包含一组数字
从0到number,不包含number
打印:
 0
 1
 2
 3
"""
for i in range(4):
 print i

"""
"range(lower, upper)" 返回1个列表，列表里包含一组数字
范围从lower到upper
prints:
 4
 5
 6
 7
"""
for i in range(4, 8):
 print i

"""
While会一直循环直到条件不再满足为止
prints:
 0
 1
 2
 3
"""
x = 0
while x < 4:
 print x
 x += 1 # x = x + 1 的简写

# try/except 代码库(block)用来处理异常

# 适用于Python 2.6及以上版本:
try:
 # 使用"raise"来抛出异常
 raise IndexError("This is an index error")
except IndexError as e:
 pass # Pass就是啥都不做.一般情况下，你会在这里做异常的恢复
except (TypeError, NameError):
 pass # 如果需要的话可以一次性处理多个异常
else: # else分支是可选的.必须出现在所有的except分支之后
 print "All good!" # 当且仅当try代码块中没有抛出任何异常时才会运行
finally: # 最后一定会执行
 print "We can clean up resources here"

# 除了使用try/finally之外，我们可以使用 with 语句来进行适当的简化
with open("myfile.txt") as f:
 for line in f:
 print line

原始封面

python简明教程: 4. 函数

Mon, 19 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

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

# 用"def" 来定义函数
def add(x, y):
 print "x is {0} and y is {1}".format(x, y)
 return x + y # 用return语句来从函数中返回具体的值


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

# 另一种调用函数的方式，使用关键字参数
add(y=6, x=5) # 使用关键字参数的话，参数出现的顺序是可以随意的


# 可以定义不定长的固定位置参数
# 使用 * 加参数名的形式
# 参数将被解析成元组
def varargs(*args):
 return args


varargs(1, 2, 3) # => (1, 2, 3)


# 可以定义不定长的关键字参数
# 使用 * 加参数名的形式
# 参数将被解析成字典
def keyword_args(**kwargs):
 return kwargs


# 调用一下看会发生什么
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}


# 也可以将两种方式结合起来使用
def all_the_args(*args, **kwargs):
 print args
 print kwargs


"""
all_the_args(1, 2, a=3, b=4) prints:
 (1, 2)
 {"a": 3, "b": 4}
"""

# 调用函数的时候其实就是对args/kwargs做反向操作
# 使用 * 来展开固定位置参数args, 使用 ** 去展开关键字参数kwargs
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # 等于是调用了 foo(1, 2, 3, 4)
all_the_args(**kwargs) # 等于 foo(a=3, b=4)
all_the_args(*args, **kwargs) # 等于 foo(1, 2, 3, 4, a=3, b=4)


# 你可以将函数参数里的args/kwargs传到其他函数里去
# 分别使用 * 和 **
def pass_all_the_args(*args, **kwargs):
 all_the_args(*args, **kwargs)
 print varargs(*args)
 print keyword_args(**kwargs)


# 函数作用域
x = 5


def set_x(num):
 # 本地变量x跟全局变量x的值是不一样的，尽管同名
 x = num # => 43
 print x # => 43


def set_global_x(num):
 global x
 print x # => 5
 x = num # 全局变量 x 现在被设为 6
 print x # => 6


set_x(43)
set_global_x(6)


# Python has first class functions
def create_adder(x):
 def adder(y):
 return x + y

 return adder


add_10 = create_adder(10)
add_10(3) # => 13

# 这是匿名函数
(lambda x: x > 2)(3) # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5

# 这是内置的高阶函数
map(add_10, [1, 2, 3]) # => [11, 12, 13]
map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3]

filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]

# 可以使用列表表达式去实现优雅的maps和filters
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]

# 也可以用字典表达式来构造集合和字典
{x for x in 'abcddeef' if x in 'abc'} # => {'a', 'b', 'c'}
{x: x ** 2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

原始封面

python简明教程: 5. 类

Sun, 18 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者


####################################################
# 5. 类
####################################################

# 以继承object的方式来定义1个类
class Human(object):
 # 类属性，所有类实例都共享
 species = "H. sapiens"

 # 基本的构造函数，当类实例化的时候会自动被调用
 # 注意双下划线开头和结尾的变量是python保留的
 # 你不应该自己定义类似风格的变量
 def __init__(self, name):
 # 将参数里name赋值给同名的实例属性
 self.name = name

 # 初始化属性
 self.age = 0

 # 实例方法，第一个参数必须是self
 def say(self, msg):
 return "{0}: {1}".format(self.name, msg)

 # 类方法，所有实例共享
 # 调用的时候第1个参数代表这个类本身
 @classmethod
 def get_species(cls):
 return cls.species

 # 静态方法被调用的时候是不需要传入类或实例的引用(kls,self)的
 @staticmethod
 def grunt():
 return "*grunt*"

 # 属性有点像getter.
 # 这个将 age() 方法变成了同名的只读的属性(调用的时候不用加括号了)
 @property
 def age(self):
 return self._age

 # 这样就可以允许属性被赋值了
 @age.setter
 def age(self, age):
 self._age = age

 # 这样就可以允许属性被删除
 @age.deleter
 def age(self):
 del self._age


# 实例化1个类
i = Human(name="Ian")
print i.say("hi") # 打印出 "Ian: hi"

j = Human("Joel")
print j.say("hello") # 打印出 "Joel: hello"

# 调用类方法
i.get_species() # => "H. sapiens"

# 修改类属性
Human.species = "H. neanderthalensis"
i.get_species() # => "H. neanderthalensis"
j.get_species() # => "H. neanderthalensis"

# 调用静态方法
Human.grunt() # => "*grunt*"

# 更新属性
i.age = 42

# 获取属性
i.age # => 42

# 删除属性
del i.age
i.age # => 抛出AttributeError异常

原始封面

python简明教程: 6. 模块

Sat, 17 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 6. 模块
####################################################

# 你可以导入1个模块
import math

print math.sqrt(16) # => 4

# 可以从module里导入一些函数
from math import ceil, floor

print ceil(3.7) # => 4.0
print floor(3.7) # => 3.0

# 可以把模块里所有的函数都导出来
# 注意: 这是不推荐的做法
from math import *

# 模块名是可以有简写的
import math as m

math.sqrt(16) == m.sqrt(16) # => True
# 你也可以测试这些函数是否相等
from math import sqrt

math.sqrt == m.sqrt == sqrt # => True

# python的模块就是普通的python文件.
# 你可以创建自己的模块，然后进行导入
# 模块就是文件的文件名

# 你可以找出模块里定义了哪些函数和属性
import math

dir(math)

# 如果你有1个名为math.py的文件
# 并且该文件跟你的脚本在同一文件夹下
# 你导入math.py的时候你将导入自己定义的版本
# 而不是python标准库的math模块
# 这是因为本地文件夹的导入优先级高于标准库

原始封面

python简明教程: 7. 高级内容

Fri, 16 Nov 2018 03:23:57 +0800

本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

####################################################
# 7. 高级内容
####################################################

# 生成器
# 生成器会动态生成一些数据，而不是在使用数据前创建数据然后把这些数据储存起来

# 下面的方法(非生成器)会将所有的值翻倍，并存在double_arr变量里
# 如果iterable很大的话，double_arr将是巨大的
def double_numbers(iterable):
 double_arr = []
 for i in iterable:
 double_arr.append(i + i)
 return double_arr


# 运行下面的代码意味着我们首先会将所有的值都加倍然后返回回来
# 最后再检查返回值是否符合特定条件
for value in double_numbers(range(1000000)): # `test_non_generator`
 print value
 if value > 5:
 break


# We could instead use a generator to "generate" the doubled value as the item
# is being requested
# 我们可以使用生成器来动态加倍必要的值

def double_numbers_generator(iterable):
 for i in iterable:
 yield i + i


# 使用生成器运行之前同样的代码
# 现在我们可以根据运行时逻辑一个接一个的进行加倍
# 一旦value > 5，代码就会break
# 这样我们就不需要把所有的值都加倍一遍了(运行速度会快很多)
for value in double_numbers_generator(xrange(1000000)): # `test_generator`
 print value
 if value > 5:
 break

# BTW: 你注意到`range` 用在了 `test_non_generator` 而`xrange` 用在 `test_generator`里了嘛?
# 就像`double_numbers_generator` 是 `double_numbers`的生成器版本一样
# `xrange` 是`range`的生成器版本
# `range` 会返回包含1000000个值的列表
# `xrange` 会在我们遍历的时候动态依次创建1000000个值

# 你也可以像使用列表表达式一样使用生成器表达式
values = (-x for x in [1, 2, 3, 4, 5])
for x in values:
 print(x) # 打印出-1 -2 -3 -4 -5

# 你也可以直接把生成器转换成列表
values = (-x for x in [1, 2, 3, 4, 5])
gen_to_list = list(values)
print(gen_to_list) # => [-1, -2, -3, -4, -5]


# 装饰器
# 装饰器是高阶函数，可以接受函数作为参数并返回函数
# 简单的例子 – add_apples装饰器会将 'Apple' 元素插入 into
# 到目标函数(被装饰的函数)get_fruits返回的列表里
def add_apples(func):
 def get_fruits():
 fruits = func()
 fruits.append('Apple')
 return fruits
 return get_fruits

@add_apples
def get_fruits():
 return ['Banana', 'Mango', 'Orange']

# 打印出的结果里是包含'Apple'元素的
# Banana, Mango, Orange, Apple
print ', '.join(get_fruits())

# 下面的例子里beg 装饰了 say
# Beg会调用say. 如果 say_please 是 True 那么 beg 会修改say的返回值
# message
from functools import wraps


def beg(target_function):
 @wraps(target_function)
 def wrapper(*args, **kwargs):
 msg, say_please = target_function(*args, **kwargs)
 if say_please:
 return "{} {}".format(msg, "Please! I am poor :(")
 return msg

 return wrapper


@beg
def say(say_please=False):
 msg = "Can you buy me a beer?"
 return msg, say_please


print say() # Can you buy me a beer?
print say(say_please=True) # Can you buy me a beer? Please! I am poor :(

原始封面