前言
转载于本人博客。
面向有编程经验者的极速入门指南。
大部分内容简化于 W3School,翻译不一定准确，因此标注了英文。
包括代码一共两万字符左右，预计阅读时间一小时。
目前我的博客长文显示效果不佳，缺乏目录，因此可以考虑下载阅读。博客完全开源于 Github.
目录
语法(Syntax)
文件执行方式：python myfile.py
强制缩进，缩进不能省略。缩进可以使用任意数量的空格。
if 5 > 2:
print("Five is greater than two!")
if 5 > 2:
print("Five is greater than two!")
注释(Comment)
注释语法：
# Single Line Comment
"""
Multiple
Line
Comment
"""
变量(Variables)
当变量被赋值时，其被创建。
没有显式声明变量的语法。
x = 5
y = "Hello, World!"
可以转换类型。
x = str(3) # x will be '3'
y = int(3) # y will be 3
z = float(3) # z will be 3.0
可以获得类型。
x = 5
y = "John"
print(type(x))
print(type(y))
还可以这样赋值：
x, y, z = "Orange", "Banana", "Cherry"
x = y = z = "Orange"
fruits = ["apple", "banana", "cherry"]
x, y, z = fruits
没有在函数中声明的变量一律视作全局变量。
x = "awesome"
def myfunc():
print("Python is " + x)
myfunc()
局部变量优先。
x = "awesome"
def myfunc():
x = "fantastic"
print("Python is " + x)
myfunc()
print("Python is " + x)
也可以显式声明全局变量。
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)
由于不能区分赋值和声明，因此如果在函数中修改全局变量，需要指明全局。
x = "awesome"
def myfunc():
global x
x = "fantastic"
myfunc()
print("Python is " + x)
数值(Number)
三种数值类型：int float complex
其中复数的虚部用 j 来表示。
x = 3+5j
y = 5j
z = -5j
print(type(x))
print(type(y))
print(type(z))
真值(Boolean)
使用 True 和 False，大小写敏感。
可以强制转换：
x = "Hello"
y = 15
print(bool(x))
print(bool(y))
空值一般转换为假，例如零、空文本、空集合等。
条件与循环(If...Else/While/For)
大于小于等于不等于跟 C 语言一致。
如果：
a = 200
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
适当压行也是可以的：
if a > b: print("a is greater than b")
三目运算符，需要注意的是执行语句在前面。
a = 2
b = 330
print("A") if a > b else print("B")
print("A") if a > b else print("=") if a == b else print("B")
与或：
a = 200
b = 33
c = 500
if a > b and c > a:
print("Both conditions are True")
if a > b or a > c:
print("At least one of the conditions is True")
如果不能为空，可以传递个 pass 占位。
if b > a:
pass
while 循环很常规：
i = 1
while i < 6:
print(i)
if i == 3:
break
if i == 4:
continue
i += 1
还有个 else 的语法：
i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")
这个有什么用呢？其实是可以判断自然结束还是被打断。
i = 1
while i < 6:
break
else:
print("i is no longer less than 6")
Python 中的 for 循环，更像是其他语言中的 foreach.
fruits = ["apple", "banana", "cherry"]
for x in fruits:
if x == "apple":
continue
print(x)
if x == "banana":
break
为了循环，可以用 range 生成一个数组。依然是左闭右开。可以缺省左边界 0.
for x in range(6): #generate an array containing 0,1,2,3,4,5
print(x)
for x in range(2, 6): #[2,6)
print(x)
可以指定步长，默认为 1.
for x in range(2, 30, 3):
print(x)
也支持 else
for x in range(6):
print(x)
else:
print("Finally finished!")
也可以拿 pass 占位。
for x in [0, 1, 2]:
pass
字符串(String)
有两种写法：
print("Hello")
print('Hello')
好像没什么区别。
多行字符串：
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)
字符串可以直接当数组用。
a = "Hello, World!"
print(a[0])
获得长度。
a = "Hello, World!"
print(len(a))
直接搜索。
txt = "The best things in life are free!"
print("free" in txt)
print("expensive" not in txt)
if "free" in txt:
print("Yes, 'free' is present.")
if "expensive" not in txt:
print("Yes, 'expensive' is NOT present.")
几个常用函数：
upper，大写。lower，小写。strip，去除两端空格。replace，替换。split，以特定分隔符分割。
连接两个字符串，直接用加号。
a = "Hello"
b = "World"
c = a + b
print(c)
格式化：
quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))
可以指定参数填入的顺序：
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))
转义符：
txt = "We are the so-called "Vikings" from the north."
操作符(Operators)
-
算术运算符
+-*/%，取模。**，次幂，例如2**10返回 (1024).//，向下取整，严格向下取整，例如-11//10将会得到 (-2).
-
比较运算符
==!=><>=<=
-
逻辑运算符，使用英文单词而非符号。
andornot
-
身份运算符？(Identity Operators)
isis not- 用于判断是否为同一个对象，即在内存中处于相同的位置。
-
成员运算符？(Membership Operators)
innot in- 用在集合中。
-
位运算符
&|^~<<>>
集合(Collections)
数组(List)
没有 Array，只有 List.
thislist = ["apple", "banana", "cherry"]
print(thislist)
下标从零开始。
thislist = ["apple", "banana", "cherry"]
print(thislist[0])
还可以是负的，-1 表示倒数第一个，依此类推。
thislist = ["apple", "banana", "cherry"]
print(thislist[-1])
获取子数组，左闭右开。例如 [2:5] 代表 [2,5)
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])
还可以去头去尾。
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])
print(thislist[2:])
获得元素个数：
thislist = ["apple", "banana", "cherry"]
print(len(thislist))
元素类型都可以不同：
list1 = ["abc", 34, True, 40, "male"]
构造：
thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
print(thislist)
赋值：
thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant"
print(thislist)
甚至一次改变一个子数组：
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]
thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)
元素数量可以不对等，可以视作将原数组中的 [l,r) 扔掉，然后从切口塞进去新的子数组。
thislist = ["apple", "banana", "cherry"]
thislist[1:2] = ["blackcurrant", "watermelon"]
print(thislist)
支持插入，应该是 (O(n)) 复杂度的。insert(x,"something") 即让 something 成为下标为 x 的元素，也就是插入到当前下标为 x 的元素前。
thislist = ["apple", "banana", "cherry"]
thislist.insert(2, "watermelon")
print(thislist)
尾部追加，应该是 (O(1)) 的。
thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)
直接连接两个数组：
thislist = ["apple", "banana", "cherry"]
tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)
啥都能连接？
thislist = ["apple", "banana", "cherry"]
thistuple = ("kiwi", "orange")
thislist.extend(thistuple)
print(thislist)
删除，一次只删一个。
thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)
按下标删除。可以省略参数，默认删除最后一个。
thislist = ["apple", "banana", "cherry"]
thislist.pop(1)
thislist.pop()
print(thislist)
还可以用 del 关键字。
thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)
del thislist #delete the entire list
清空，数组对象依然保留。
thislist = ["apple", "banana", "cherry"]
thislist.clear()
print(thislist)
可以直接用 for 来遍历。
thislist = ["apple", "banana", "cherry"]
for x in thislist:
print(x)
也可以用下标遍历。
thislist = ["apple", "banana", "cherry"]
for i in range(len(thislist)):
print(thislist[i])
为了性能，也可以用 while 来遍历，避免 range 生成过大的数组。
thislist = ["apple", "banana", "cherry"]
i = 0
while i < len(thislist):
print(thislist[i])
i = i + 1
缩写的 for 遍历，两边中括号是必须的。
thislist = ["apple", "banana", "cherry"]
[print(x) for x in thislist]
赋值的时候，也有一些神奇的语法糖：
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
newlist = [x for x in fruits if "a" in x]
#Equals to
for x in fruits:
if "a" in x:
newlist.append(x)
print(newlist)
更抽象地：
newlist = [expression for item in iterable if condition == True]
还是比较灵活的：
newlist = [x.upper() for x in fruits]
支持直接排序。
thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
thislist.sort()
print(thislist)
排序也有一些参数。
thislist = [100, 50, 65, 82, 23]
thislist.sort(reverse = True)
print(thislist)
可以自定义估值函数，返回一个对象用于比较？
def myfunc(n):
return abs(n - 50)
thislist = [100, 50, 65, 82, 23]
thislist.sort(key = myfunc)
print(thislist)
还有这样的：
thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort(key = str.lower) #case insensitive
print(thislist)
所以其实排序内部可能是这样的：
if key(a) > key(b):
a,b = b,a #swap the objects
翻转数组：
thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.reverse()
print(thislist)
直接拷贝只能拷贝到引用，所以有拷贝数组：
thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)
也可以直接构造：
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)
合并：
list1 = ["a", "b", "c"]
list2 = [1, 2, 3]
list3 = list1 + list2
print(list3)
总结一下内置函数：
append，尾部追加。clear，清空。copy，生成副本。count，数数用的。extend，连接两个数组。index，查找第一个满足条件的元素的下标。insert，插入。pop，按下标删除。remove，按值删除。reverse，翻转。sort，排序。
元组(Tuple)
元组可以看作是不可修改的 List.
用圆括号包裹。
thistuple = ("apple", "banana", "cherry")
print(thistuple)
与 List 不同的是，单元素的元组声明时，必须加一个句号，否则不会识别为元组。
myList = ["list"]
myTuple = ("tuple") #not Tuple!
myRealTuple = ("tuple",) #is Tuple!
print(type(myList))
print(type(myTuple))
print(type(myRealTuple))
构造：
thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)
元组是不可变的(immutable)，想要修改只能变成 List，改完再生成元组。当然这样做效率很低。
x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)
当我们创建元组时，我们将变量填入，这被称为「打包(packing)」.
而我们也可以将元组重新解析为变量，这被称为「解包(unpacking)」.
fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits
print(green)
print(yellow)
print(red)
有趣的是，元组不能修改，却能连接，这大概是因为运算过程产生了新的元组而作为返回值。
tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
print(tuple3)
fruits = ("apple", "banana", "cherry")
mytuple = fruits * 2 #interesting multiply <=> mytuple = fruits + fruits + ... times.
print(mytuple)
集合(Sets)
这个集合是数学意义上的集合，即具有无序性、不重复性、确定性的特性的集合。
用大括号：
thisset = {"apple", "banana", "cherry"}
print(thisset)
集合不支持下标访问，只能遍历：
thisset = {"apple", "banana", "cherry"}
for x in thisset:
print(x)
不能修改元素，但可以添加元素。也可以删除再添加来达到修改的效果。
thisset = {"apple", "banana", "cherry"}
thisset.add("orange")
print(thisset)
简单的删除 remove，如果删除的元素不存在会报错。
thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)
如果不想要报错，可以用 discard：
thisset = {"apple", "banana", "cherry"}
thisset.discard("banana")
print(thisset)
甚至可以用 pop，由于无序性，可能会随机删除一个元素？
thisset = {"apple", "banana", "cherry"}
x = thisset.pop()
print(x)
print(thisset)
取并集，也就是合并两个集合，需要使用 update，合并后会去重。
thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}
thisset.update(tropical)
print(thisset)
当然合并不仅限于集合之间。
thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]
thisset.update(mylist)
print(thisset)
如果不想影响原集合，只需要返回值，可以用 union：
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)
取交集：
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.intersection(y) #like union
x.intersection_update(y) #like update
print(x)
还有更有趣的，删去交集，即 ((mathbb{A} cup mathbb{B}) setminus (mathbb{A} cap mathbb{B}))
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.symmetric_difference(y)
x.symmetric_difference_update(y)
print(x)
清空和彻底删除：
thisset = {"apple", "banana", "cherry"}
thisset.clear()
print(thisset)
del thisset
print(thisset)
字典(Dictionary)
类似于 C++ 中的 map，键值对。
3.7 以上的 Python 版本中，字典是有序的。有序性、可变性、不重复性。
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)
print(thisdict["brand"])
print(thisdict.get("model")) #the same with the former approach
有趣的是，值可以是任意数据类型。
thisdict = {
"brand": "Ford",
"electric": False,
"year": 1964,
"colors": ["red", "white", "blue"]
}
获取所有 key：
x = thisdict.keys()
值得注意的是，这里传出的是一个引用，也就是说是可以动态更新的。但似乎是只读的。
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.keys()
print(x) #before the change
car["color"] = "white"
print(x) #after the change
values 也是一样的：
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.values()
print(x) #before the change
car["year"] = 2020
print(x) #after the change
还可以直接获取所有键值对 items：
car = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
x = car.items()
print(x) #before the change
car["year"] = 2020
print(x) #after the change
可以查看键是否存在：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
if "model" in thisdict:
print("Yes, 'model' is one of the keys in the thisdict dictionary")
可以用 update 来更新，支持塞入一个键值对集合：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
another = {
"another": "Intersting",
"stuff": "Join it"
}
thisdict.update({"year": 2020})
print(thisdict)
thisdict.update(another)
print(thisdict)
移除特定键：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.pop("model")
print(thisdict)
移除最后一个键值对：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.popitem()
print(thisdict)
thisdict.update({"new":"I'm newer"})
print(thisdict)
thisdict.popitem()
print(thisdict)
可以用 del 关键字：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict["model"]
print(thisdict)
清空：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.clear()
print(thisdict)
遍历所有键名：
for x in thisdict:
print(x)
遍历所有值：
for x in thisdict:
print(thisdict[x]) #have to search for the value each time executed
直接获取集合来遍历：
for x in thisdict.values():
print(x)
for x in thisdict.keys():
print(x)
遍历键值对：
for x, y in thisdict.items():
print(x, y)
深拷贝：
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
mydict = thisdict.copy()
print(mydict)
mydict = dict(thisdict)
print(mydict)
嵌套：
child1 = {
"name" : "Emil",
"year" : 2004
}
child2 = {
"name" : "Tobias",
"year" : 2007
}
child3 = {
"name" : "Linus",
"year" : 2011
}
myfamily = {
"child1" : child1,
"child2" : child2,
"child3" : child3
}
print(myfamily["child1"]["name"])
函数(Functions)
函数定义：
def my_function():
print("Hello from a function")
my_function()
参数：
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
形参(Parameter)和实参(Argument).
不定长参数：
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
可以用更优雅的方式传参：
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
实质上是键值对的传递，因此：
def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
默认参数：
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
弱类型，啥都能传：
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
返回值：
def my_function(x):
return 5 * x
占位符：
def myfunction():
pass
Lambda 表达式
只能有一行表达式，但可以有任意个数参数。
lambda arguments : expression
例如一个自增 (10) 的函数：
x = lambda a : a + 10
print(x(5))
多参数：
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))
有趣的是，可以利用 Lambda 表达式构造匿名函数：
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
mytripler = myfunc(3)
print(mydoubler(11))
print(mytripler(11))
类和对象(Classes/Objects)
Python 是一个面向对象(Object Oriented)的语言。
class MyClass:
x = 5
p1 = MyClass()
print(p1.x)
初始化：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age)
声明方法：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1 = Person("John", 36)
p1.myfunc()
函数的第一个参数将会是指向自己的引用，并不强制命名为 self.
class Person:
def __init__(mysillyobject, name, age):
mysillyobject.name = name
mysillyobject.age = age
def myfunc(abc):
print("Hello my name is " + abc.name)
p1 = Person("John", 36)
p1.myfunc()
可以删除某个属性：
del p1.age
可以删除对象：
del p1
占位符：
class Person:
pass
继承(Inheritance)
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
#Use the Person class to create an object, and then execute the printname method:
x = Person("John", "Doe")
x.printname()
class Student(Person):
def __init__(self, fname, lname, year): # overwrite parent's __init__
super().__init__(fname, lname)
# <=> Person.__init__(self, fname, lname)
self.graduationyear = year
def welcome(self):
print("Welcome", self.firstname, self.lastname,
"to the class of", self.graduationyear)
def printname(self):
super().printname()
print("plus {} is a student!".format(self.lastname))
x = Student("Mike", "Olsen", 2020)
x.welcome()
x.printname()
迭代器(Iterators)
一个迭代器需要有 __iter__ 和 __next__ 两个方法。
所有的集合都能提供迭代器，都是可遍历的(Iterable Containers).
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)
print(next(myit))
print(next(myit))
print(next(myit))
创建一个迭代器：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration #Stop iterating
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
定义域(Scope)
函数中声明的变量只在函数中有效。
def myfunc():
x = 300
print(x)
myfunc()
事实上，它在该函数的域内有效。
def myfunc():
x = 300
def myinnerfunc():
print(x)
myinnerfunc()
myfunc()
全局变量：
x = 300
def myfunc():
print(x)
myfunc()
print(x)
更多有关全局变量的前文已经说过，这里复习一下。
x = 300
def myfunc():
global x
x = 200
def myfunc2():
x = 400
print(x)
myfunc()
myfunc2()
print(x)
模块(Modules)
调库大法好。
举个例子，在 mymodule.py 中保存以下内容：
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
def greeting(name):
print("Hello, " + name)
然后在 main.py 中运行：
import mymodule
mymodule.greeting("Jonathan")
a = mymodule.person1["age"]
print(a)
可以起别名(Alias)：
import mymodule as mx
a = mx.person1["age"]
print(a)
有一些内置的模块：
import platform
x = platform.system()
print(x)
x = dir(platform)
print(x)
可以指定引用模块的某些部分，此时不需要再写模块名：
from mymodule import person1
print (person1["age"])
#print(mymodule.person1["age"]) WRONG!!
也可以起别名：
from mymodule import person1 as p1
print (p1["age"])
PIP
包管理器。
安装包：pip install <package-name>
例如：pip install camelcase
然后就能直接使用了：
import camelcase
c = camelcase.CamelCase()
txt = "hello world"
print(c.hump(txt))
异常捕获(Try...Except)
比较常规。
try:
print(x)
except NameError:
print("Variable x is not defined")
except:
print("Something else went wrong")
else:
print("Nothing went wrong")
finally:
print("Ended.")
举个例子：
try:
f = open("demofile.txt")
f.write("Lorum Ipsum")
except:
print("Something went wrong when writing to the file")
finally:
f.close()
抛出异常：
x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")
可以指定类型：
x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")
输入(Input)
很简单的输入。
username = input("Enter username:")
print("Username is: " + username)
格式化字符串(Formatting)
前文已经简单提及了。
price = 49
txt = "The price is {} dollars"
print(txt.format(price))
可以指定输出格式：
quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))
可以重复利用：
age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))
可以传键值对：
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Ford", model = "Mustang"))
结语
差不多把 Python 中的基础语法过了一遍，相信各位读者读完后都能入门吧。
大部分编程概念都是相似的，学习起来并不困难。这也是一个写起来没什么心智负担的工具语言。有什么需要直接面向谷歌编程即可。