python基础

字数统计: 8.4k字   |   阅读时长≈ 37分

摘要：python一些入门基础总结

前言：这几天着手学爬虫，前4天把python基础过一遍，这篇文章是python入门基础的总结

变量和简单数据类型

用引号括起的都是字符串，单引号和双引号都可以

1
2
name = "ada lovelace"
name = 'ada lovelace'

title()首字母大写

1
print(name.title())

upper()全部大写

1
print(name.upper())

lower()全部小写

1
2
name = "ABCD"
print(name.lower())

合并（拼接）字符串

1
2
3
4
5
6
7
first_name = 'ada'
last_name = 'lovelace'
full_name = first_name + " " + last_name
print(full_name)
print("Hello, " + full_name.title() + "!")
messages = "Hello, " + full_name.title() + "!"
print(messages)

\t制表符，\n换行

1
2
print("\tpython".title())
print("\tpython \n\thello".title())

rstrip()删除字符串末尾多余的空白

1
2
favorite_language = ' hello python '
print(favorite_language.rstrip())

lstrip()删除字符串开头多余的空白

1
print(favorite_language.lstrip())

strip()删除字符串两端的空白

1
print(favorite_language.strip())

python使用两个乘号表示乘方运算

1
2
3
print(3 ** 2)

结果为：9

python支持运算次序，可以使用括号来修改运算次序

1
2
print(2 + 3 * 4)
print((2 + 3) * 4)

str()将非字符串表示成字符串

1
2
3
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

python2.7中：，计算整数结果时，采取的方式不是四舍五入，而是将小数部分直接删除。

1
2
3
print(3/2)

结果为：1

在Python 2中，若要避免这种情况，务必确保至少有一个操作数为浮点数，这样结果也将为浮点数

1
print(3.0/2)

注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 这是一个注释

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''

"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""

Python之禅

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

列表

特性

  • 列表由一系列按特定顺序排列的元素组成。
  • 其中的元素之间可以没有任何关系。
  • 索引从0 而不是1 开始。
  • 通过将索引指定为-1，可让Python返回最后一个列表元素。
1
2
arr = ['a',8,'c','d']
print(arr[1])

修改、添加和删除元素

修改列表元素

通过列表下标修改元素

1
2
3
4
5
6
7
8
9
10
11

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)

motorcycles[0] = 'ducati'
print(motorcycles)

结果为：
['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']

在列表中添加元素

1、在列表末尾添加元素

使用方法append()将元素添加到了列表末尾

1
2
3
4
5
6
7

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)

motorcycles.append('ducati')
print(motorcycles)

2、在列表中插入元素

使用方法insert()可在列表的任何位置添加新元素。

1
2
3
4
5

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)

从列表中删除元素

1、使用del语句删除元素

如果知道要删除的元素在列表中的位置，可使用del语句。

1
2
3
4
5
6

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)

2、使用方法pop()删除元素

方法pop()可删除列表末尾的元素，并让你能够接着使用它。术语弹出（pop）源自这样的类
比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

1
2
3
4
5
6
7

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

3、弹出列表中任何位置处的元素

实际上，可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素
的索引即可。

1
2
3
4
5
6
7
8

motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(1)
print('The first motorcycle I owned was a ' + first_owned.title() + '.')

结果为：
The first motorcycle I owned was a Yamaha.

如果你不确定该使用del语句还是pop()方法，下面是一个简单的判断标准：如果你要从列表
中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续
使用它，就使用方法pop()。

4、根据值删除元素

如果你只知道要删除的元素的值，可使用方法remove()。

1
2
3
4
5
6

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
motorcycles.remove('ducati')
print(motorcycles)

注意：方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要
使用循环来判断是否删除了所有这样的值。

组织列表

1、使用方法sort()对列表进行永久性排序

方法sort()是永久性地修改了列表元素的排列顺序，再也无法恢复到原来的排列顺序。

1
2
3
4
5

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)

还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort()方法传递参数
reverse=True。下面的示例将汽车列表按与字母顺序相反的顺序排列：

1
2
3
4
5

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)
print(cars)

2、使用函数sorted()对列表进行临时排序

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()。函数
sorted()让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)
print("\nHere is the sorted list:")
print(sorted(cars))
print("\nHere is the original list again:")
print(cars)

结果为：
Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']

Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']

Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']

注意，调用函数sorted()后，列表元素的排列顺序并没有变。如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted()传递参数reverse=True。

3、倒着打印列表

要反转列表元素的排列顺序，可使用方法reverse()。

1
2
3
4
5
6
7
8
9
10

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)

注意，reverse()不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：
['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']

4、确定列表的长度

使用函数len()可快速获悉列表的长度。

1
2
3
4

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(len(cars))

操作列表

遍历整个列表

1
2
3
4
5
6
7
8
9
10
11

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

for i in range(0,3):
    magicians[i] = magicians[i] + "ggggg"

for magician in magicians:
    print(magician)

创建数值列表

1、使用函数range()

Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数
range()来打印一系列的数字：

1
2
3
4
5
6
7
8
9
10

for value in range(1,5):
    print(value)

结果为：
1
2
3
4

2、使用range()创建数字列表

要创建数字列表，可使用函数list()将range()的结果直接转换为列表。如果将range()作为list()的参数，输出将为一个数字列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

numbers = list(range(1,6))
print(numbers)

结果为：
[1, 2, 3, 4, 5]

使用函数range()时，还可指定步长。例如，下面的代码打印1~10内的偶数：
even_numbers = list(range(2,11,2))
print(even_numbers)

在这个示例中，函数range()从2开始数，然后不断地加2，直到达到或超过终值（11），因此
输出如下：
[2, 4, 6, 8, 10]


squares = []
for value in range(1, 11):
    squares.append(value ** 2)

print(squares)

3、对数字列表执行简单的统计计算

1
2
3
4
5
6
7
8
9
10
11

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(min(digits))
print(max(digits))
print(sum(digits))

结果为：
0
9
45

4、列表解析

1
2
3
4
5
6
7
8
9

要使用这种语法，首先指定一个描述性的列表名，如squares；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式为value**2，它计算平方值。接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。

squares = [value**2 for value in range(1,11)]
print(squares)

结果为：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4、列表解析（切片）

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])

结果为：
['charles', 'martina', 'michael']

如果你没有指定第一个索引，Python将自动从列表开头开始：
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[:4])

结果为：
['charles', 'martina', 'michael', 'florence']

要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末
尾的所有元素，可将起始索引指定为2，并省略终止索引：
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[2:])

结果为：
['michael', 'florence', 'eli']

负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。例如，如果你
要输出名单上的最后三名队员，可使用切片players[-3:]：
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])

结果为：
['michael', 'florence', 'eli']

5、遍历切片

如果要遍历列表的部分元素，可在for循环中使用切片。

1
2
3
4
5
6

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

6、复制列表

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:]）。
这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)

倘若我们只是简单地将my_foods赋给friend_foods，就不能得到两个列表。
例如，下例演示了在不使用切片的情况下复制列表的情况：
my_foods = ['pizza', 'falafel', 'carrot cake']
#这行不通
friend_foods = my_foods
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)

结果为：
My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

这里将my_foods赋给friend_foods，而不是将my_foods的副本存储到friend_foods。
这种语法实际上是让Python将新变量friend_foods关联到包含在my_foods中的列表，因此这两个
变量都指向同一个列表。鉴于此，当我们将'cannoli'添加到my_foods中时，它也将出现在
friend_foods中；同样，虽然'ice cream'好像只被加入到了friend_foods中，但它也将出现在这
两个列表中。

元组

Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来
访问其元素，就像访问列表元素一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

结果为：
200
50

dimensions[0] = 250
print(dimensions[0])

结果为：
Traceback (most recent call last):
  File "D:/ProgramFiles/python/poj/venv/demo_02.py", line 71, in <module
    dimensions[0] = 250
TypeError: 'tuple' object does not support item assignment

遍历元组中的所有值

像列表一样，也可以使用for循环来遍历元组中的所有值：

1
2
3
4
5

dimensions = (200, 50)
for dimension in dimensions:
print(dimension)

修改元组变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺
寸，可重新定义整个元组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

结果为：
Original dimensions:
200
50

dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

结果为：
Modified dimensions:
400
100

if语句

简单示例：

1
2
3
4
5
6
7
8
9
10
11

cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

requested_topping = 'mushrooms'
if requested_topping.lower() != 'anchovies':
    print("Hold the anchovies!")

检查多个条件

使用and检查多个条件，如果每个测试都通过了，整个表达式就为True；如果至少有一个测试没有通过，整个表达式就为False。

关键字or也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。

1
2
3
4
5
6
7
8
9
10

a1 = 29
a2 = 66
if a1 >= 25 and a2 < 55 :
    print("yes and")
else:
    if a1 >= 25 or a2 < 55:
        print("yes or")
    else:
        print("GG")

检查特定值是否包含在列表中

要判断特定的值是否已包含在列表中，可使用关键字in。

1
2
3
4
5

requested_toppings = ['mushrooms', 'onions', 'pineapple']
print('mushrooms' in requested_toppings)
print('pepperoni' in requested_toppings)

检查特定值是否不包含在列表中

有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in。

1
2
3
4
5
6

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:
    print(user.title() + ", you can post a response if you wish.")

if-elif-else 结构

1
2
3
4
5
6
7
8
9
10
11
12

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 5
elif age < 65:
    price = 10
else:
    price = 5
print("Your admission cost is $" + str(price) + ".")

测试多个条件

1
2
3
4
5
6
7
8
9
10

requested_toppings = ['mushrooms', 'extra cheese']
if 'mushrooms' in requested_toppings:
    print("Adding mushrooms.")
if 'pepperoni' in requested_toppings:
    print("Adding pepperoni.")
if 'extra cheese' in requested_toppings:
    print("Adding extra cheese.")
print("\nFinished making your pizza!")

字典

在Python中，字典是一系列键—值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值，可将任何Python对象用作字典中的值。

在Python中，字典用放在花括号{}中的一系列键—值对表示，如示例所示：

1
2
3
4
5

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

1、添加键值对

1
2
3
4
5
6
7

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

2、修改字典中的值

1
2
3
4
5
6

alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

3、删除键—值对

对于字典中不再需要的信息，可使用del语句将相应的键—值对彻底删除。使用del语句时，必须指定字典名和要删除的键。

1
2
3
4
5
6

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)

4、遍历字典

遍历所有的键—值对

方法items()它返回一个键—值对列表。

1
2
3
4
5
6
7
8
9
10

user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
for key, value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

遍历字典中的所有键

方法keys()它返回一个键

1
2
3
4
5
6
7
8
9
10

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in favorite_languages.keys():
    print(name.title())

按顺序遍历字典中的所有键

1
2
3
4
5
6
7
8
9
10

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in sorted(favorite_languages.keys()):
    print(name.title() + ", thank you for taking the poll.")

遍历字典中的所有值

使用方法values()，它返回一个值列表，而不包含任何键。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())

剔除重复项，可使用集合（set），集合类似于列表，但每个元素都必须是独一无二。
for language in set(favorite_languages.values()):
    print(language.title())

用户输入和while循环

函数input()

函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在
一个变量中，以方便你使用。input()将输入解读为字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13

name = input("Please enter your name: ")
print("Hello, " + name + "!")

prompt = "If you tell us who you are, we can personalize the messages you see."
prompt += "\nWhat is your first name? "
name = input(prompt)
print("\nHello, " + name + "!")


如果你使用的是Python 2.7，应使用函数raw_input()来提示用户输入。这个函数与Python 3
中的input()一样，也将输入解读为字符串。

函数int()

使用函数int()，它让Python将输入视为数值。函数int()将数字的字符串表示转换为数值表示。

1
2
3
4
5

age = input("How old are you? ")
age = int(age)
print(age >= 18)

求模运算符

求模运算符（%），它将两个数相除并返回余数。

1
2
3
4
5
6

print(4%4)
print(5%4)
print(6%4)
print(7%4)

使用while 循环

1
2
3
4
5
6
7
8

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1
    if current_number == 4:
        break;

函数

定义函数

1
2
3
4
5
6
7

def greet_user(username):
    """显示简单的问候语"""
    print("Hello, " + username.title() + "!")

greet_user('jesse')

形参和实参

在函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信息。在代码greet_user(‘jesse’)中，值’jesse’是一个实参。实参是调用函数时传递给函数的信息。我们调用函数时，将要让函数使用的信息放在括号内。在greet_user(‘jesse’)中，将实参’jesse’传递给了函数greet_user()，这个值被存储在形参username中。

位置实参

你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，
最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。

  1. 调用函数多次
  2. 位置实参的顺序很重要
1
2
3
4
5
6
7
8
9
10
11

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')
describe_pet('dog', 'willie')

实参位置必须对应：
describe_pet('harry', 'hamster')

关键字实参

关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

1
2
3
4
5
6
7
8

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet(pet_name='harry', animal_type='hamster')

默认值

编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。使用默认值可简化函数调用，还可清楚地指出函数的典型用法。

1
2
3
4
5
6
7
8
9
10

def describe_pet(pet_name, animal_type='dog'):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet(pet_name='willie')

由于没有给animal_type提供实参，因此Python使用其默认值'dog'

返回值

在函数中，可使用return语句将值返回到调用函数的代码行。

1
2
3
4
5
6
7
8

def get_formatted_name(first_name, last_name):
    """返回整洁的姓名"""
    full_name = first_name + ' ' + last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)

让实参变成可选的

1
2
3
4
5
6
7
8
9
10
11
12
13

def get_formatted_name(first_name, last_name, middle_name=''):
    """返回整洁的姓名"""
    if middle_name:
        full_name = first_name + ' ' + middle_name + ' ' + last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)

返回字典

函数可返回任何类型的值，包括列表和字典等较复杂的数据结构。

1
2
3
4
5
6
7
8

def build_person(first_name, last_name):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first': first_name, 'last': last_name}
    return person
musician = build_person('jimi', 'hendrix')
print(musician)

传递列表

1
2
3
4
5
6
7
8
9

def greet_users(names):
    """向列表中的每位用户都发出简单的问候"""
    for name in names:
        msg = "Hello, " + name.title() + "!"
        print(msg)
usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

禁止函数修改列表

可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。要将列表的副本传递给函数，可以像下面这样做：

1
2
3
4
5
6
7
8
9
10
11
12

function_name(list_name[:])

print_models(unprinted_designs[:], completed_models)


这样函数print_models()依然能够完成其工作，因为它获得了所有未打印的设计的名称，但
它使用的是列表unprinted_designs的副本，而不是列表unprinted_designs本身。

虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否
则还是应该将原始列表传递给函数，因为让函数使用现成列表可避免花时间和内存创建副本，从
而提高效率，在处理大型列表时尤其如此。

传递任意数量的实参

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封
装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函
数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，
Python将实参封装到一个元组中，即便函数只收到一个值也如此：
('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

1
2
3
4
5
6
7
8
9
10

def make_pizza(size, *toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) +
          "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

使用任意数量的关键字实参

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切"""
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile


user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')
print(user_profile)

函数build_profile()的定义要求提供名和姓，同时允许用户根据需要提供任意数量的名称—
值对。形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所
有名称—值对都封装到这个字典中。在这个函数中，可以像访问其他字典那样访问user_info中的
名称—值对。

将函数存储在模块中

导入整个模块

import语句允许在当前运行的程序文件中使用模块中的代码。

1
2
3

import pizza

导入特定的函数

1
2
3
4
5
6
7

from module_name import function_name

from pizza import make_pizza

from module_name import function_0, function_1, function_2

使用as 给函数指定别名

1
2
3
4
5
6
7
8
9

from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

通用语法：
from module_name import function_name as fn

使用as 给模块指定别名

1
2
3
4
5
6
7
8
9

import pizza as p

p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

通用语法：
import module_name as mn

导入模块中的所有函数

1
2
3
4
5
6
7
8
9

from pizza import *

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

通用语法：
from module_name import *

类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Dog():
    """一次模拟小狗的简单尝试"""

    def __init__(self, name, age):
        """"初始化属性name和age"""
        self.name = name
        self.age = age

    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")

    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + " rolled over!")

python2.7

class Dog(object):
    --snip--

#根据类创建实例
my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

继承

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        self.odometer_reading += miles

class ElectricCar(Car):
    """电动汽车的独特之处"""

    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)


my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())


python2.7

class Car(object):
    def __init__(self, make, model, year):
        --snip--


class ElectricCar(Car):
    def __init__(self, make, model, year):
        super(ElectricCar, self).__init__(make, model, year)
        --snip--

创建子类时，父类必须包含在当前文件中，且位于子类前面。我们定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息。super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。父类也称为超类（superclass），名称super因此而得名。

导入类

1
2
3
4
5
6
7
8
9
10

#从一个模块中导入多个类
from car import Car, ElectricCar

#导入整个模块
import car

#导入模块中的所有类
from module_name import *

顺序字典

要创建字典并记录其中的键—值对的添加顺序，可使用模块collections中的OrderedDict类。OrderedDict实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13

from collections import OrderedDict

favorite_languages = OrderedDict()
favorite_languages['jen'] = 'python'
favorite_languages['sarah'] = 'c'
favorite_languages['edward'] = 'ruby'
favorite_languages['phil'] = 'python'

for name, language in favorite_languages.items():
    print(name.title() + "'s favorite language is " +
        language.title() + ".")

文件和异常

从文件中读取数据

1
2
3
4
5

with open('text.txt') as file_object:
    contents = file_object.read()
    print(contents.rstrip())

逐行读取

1
2
3
4
5
6
7
8
9
10
11
12
13

filename = 'pi_digits.txt'

with open(filename) as file_object:
    for line in file_object:
        print(line)

每行的末尾都有一个看不见的换行符，而print语句也会加上一个换行符，
因此每行末尾都有两个换行符：一个来自文件，另一个来自print语句。
要消除这些多余的空白行，可在print语句中使用rstrip()

print(line.rstrip())

写入文件

打开文件时，可指定读取模式（’r’）、写入模式（’w’）、附加模式（’a’）或让你能够读取和写入文件的模式（’r+’）。如果你省略了模式实参，Python将以默认的只读模式打开文件。

1
2
3
4
5
6
7
8
9
10

filename = 'programming.txt'

with open(filename, 'w') as file_object:
    file_object.write("I love programming.")

如果你要写入的文件不存在，函数open()将自动创建它。
然而，以写入（'w'）模式打开文件时千万要小心，
因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。

写入多行

函数write()不会在你写入的文本末尾添加换行符，因此如果你写入多行时没有指定换行符，文件看起来可能不是你希望的那样。

1
2
3
4
5
6
7
8
9
10
11
12
13

filename = 'programming.txt'
with open(filename, 'w') as file_object:
    file_object.write("I love programming.")
    file_object.write("I love creating new games.")

要让每个字符串都单独占一行，需要在write()语句中包含换行符

filename = 'programming.txt'
with open(filename, 'w') as file_object:
    file_object.write("I love programming.\n")
    file_object.write("I love creating new games.\n")

附加到文件

如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。

1
2
3
4
5
6
7

filename = 'programming.txt'

with open(filename, 'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")
    file_object.write("I love creating apps that can run in a browser.\n")

异常

异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。

使用try-except代码块

1
2
3
4
5
6

try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

else 代码块

try-except-else代码块的工作原理大致如下：Python尝试执行try代码块中的代码；只有可能引发异常的代码才需要放在try语句中。有时候，有一些仅在try代码块成功执行时才需要运行的代码；这些代码应放在else代码块中。except代码块告诉Python，如果它尝试运行try代码块中的代码时引发了指定的异常，该怎么办。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

print("Give me two numbers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
    first_number = input("\nFirst number: ")
    if first_number == 'q':
        break
    second_number = input("Second number: ")
    try:
        answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("You can't divide by 0!")
    else:
        print(answer)

处理FileNotFoundError 异常

使用文件时，一种常见的问题是找不到文件：你要查找的文件可能在其他地方、文件名可能不正确或者这个文件根本就不存在。对于所有这些情形，都可使用try-except代码块以直观的方式进行处理。

1
2
3
4
5
6
7
8
9
10

filename = 'alice.txt'

try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except FileNotFoundError:
    msg = "Sorry, the file " + filename + " does not exist."
    print(msg)

分析文本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

def count_words(filename):
    """计算一个文件大致包含多少个单词"""
    try:
        with open(filename) as f_obj:
            contents = f_obj.read()
    except FileNotFoundError:
        msg = "Sorry, the file " + filename + " does not exist."
        print(msg)
    else:
        # 计算文件大致包含多少个单词
        words = contents.split()
        num_words = len(words)
        print("The file " + filename + " has about " + str(num_words) +
              " words.")

filenames = ['alice.txt', 'siddhartha.txt', 'moby_dick.txt', 'little_women.txt']

for filename in filenames:
    count_words(filename)

Python有一个pass语句，可在代码块中使用它来让Python什么都不要做

def count_words(filename):
    """计算一个文件大致包含多少个单词"""
    try:
        --snip--
    except FileNotFoundError:
        pass
    else:
        --snip--

存储数据

使用json.dump()和json.load()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import json

numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
    json.dump(numbers, f_obj)

filename = 'numbers.json'
with open(filename) as f_obj:
    numbers = json.load(f_obj)

print(numbers)

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

教练，我想学技术！
我主要是以后端技术为主，偶尔看看网络安全相关的内容，或者编写一些有趣的脚本！