文章目录
基础语法部分Ⅱ
七、if…elif…else
格式要严谨，用法如下：
if x1: #if放在第一个
print(...)
elif x2: #elif可以多个，可有可无，且必须加条件
print(...)
elif x3:
print(...)
else: #else放在最后，可有可无，且不可加条件。当前边的条件都不满足时，执行该语句
print(...)
#满足其中一个条件则执行其条件下的语句，不满足则一直往下判断。
八、while循环
while循环每次先判断 x < N，如果为True，则执行循环体的代码块，否则，退出循环。
x = 0
while x<10:
print(x)
x = x + 1
九、for循环 / 遍历list、dict
(1) range()函数
python的内置函数，它可以有三个参数：range(a, b, c)
a: 计数从a开始。不填时，默认从0开始。
b: 计数到b结束，不包括b。
c: 计数的间隔，不填时默认为1。
它最常用来遍历list、dict等：
list1 = [1, 1, 2.0, '3']
dict1 = {1: 'one', 2: 'two', 3: 'three'}
#遍历list1中的元素
for i in list1:
print(i)
for i in range(len(list1)): #把list的每个元素迭代出来
print(list1[i])
for i in dict1: #迭代dict1的key值，若要得到value值，还要用dict[key]的方式
print(i,dict1[i])
有没有更简单的方法遍历dict的value？
用range()生成列表
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
条件过滤生成列表
如果我们只想要偶数的平方，不改动 range()的情况下，可以加上 if 来筛选：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
多层表达式生成列表
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
翻译成循环代码就像下面这样：
list2 = []
for m in 'ABC':
for n in '123':
list2.append(m + n)
(2) dict 的 values()方法 / itervalues()方法
这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：
dict1 = {1: 'one', 2: 'two', 3: 'three'}
for i in dict1.values(): #换成dict1.itervalues()效果一样
print(i) #打印出来的是dict1中的所有value值
这两个方法的不同之处是：
values() 方法实际上把一个 dict 转换成了包含 value 的list。
但是 itervalues()方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
(3) dict的items()方法 / iteritems()方法
此方法可以同时迭代key和value：
>>> dict1 = {1: 'one', 2: 'two', 3: 'three'}
>>> print(dict1.items())
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：
>>> dict1 = {1: 'one', 2: 'two', 3: 'three'}
>>> for k,v in dict1.items():
... print(k,':',v)
1 : one
2 : two
3 : three
和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
十、print()输出格式
(1) 格式符
| 格式符+类型码 | 含义 |
|---|---|
| %s | 字符串显示 |
| %f | 浮点数显示 |
| %d | 整数显示 |
这些格式符就是用来占位置的，str % ()。用法示例：
>>> print('%s%d'%('数字：',0))
数字：0
>>> print('%d，%d，%d'%(0,1,0))
0，1，0
>>> str1 = 'Python'
>>> print('I use %s.'% str1)
I use Python
(2) end参数
print()函数中有一个end参数，实参是’str’类型，默认为end=’\n’，是用来控制换行行数和结尾字符。所以我们之前print之后都会换行。用法示例：
>>> print(1,end='23')
123
>>> print('我不要换行',end='')
我不要换行
(3) format()格式化函数
format()函数用来占位的是大括号{}，不用区分类型码（%+类型码）。
具体的语法是：str.format()，而不是之前提到的str % ()。
而且，它对后面数据的引用更灵活，不限次数，也可指定对应关系。用法示例：
>>> print('\n{}{}'.format('数字：',0)) # 优势1：不用担心用错类型码。
数字：0
>>> print('{}，{}'.format(0,1)) # 不设置指定位置时，默认按顺序对应。
0，1
>>> print('{1}，{0}'.format(0,1)) # 优势2：当设置 指定位置 时，按指定的对应。{}里的数字是format()括号里参数对应的索引
1，0
>>> x0 = 6
>>> x1 = 7
>>> print('{0}，{1}，{0}'.format(x0,x1)) # 优势3：可多次调用format后的数据。
6, 7, 6
十一、异常处理：try…except…
为了不让一些无关痛痒的小错影响程序的后续执行，Python给我们提供了一种异常处理的机制，可以在异常出现时即时捕获，然后内部消化掉，让程序继续运行，使用方法及用法示例如下：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
try:
#先尝试执行下列代码
age = int(input('请输入一个数字：'))
except ValueError:
#除非发生报错（except后面跟报错类型）就执行下面的代码
print('要输入数字嗷')
关于Python的所有报错类型，有需要的话可以点击这里查阅。
十二、函数
(1) 函数调用
Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。调用函数的时候，要按参数的位置传参。如果传入的参数数量不对，会报TypeError的错误
>>> abs(-1)
1
>>> abs(1,-1)
TypeError: abs() takes exactly one argument (2 given)
点击查阅更多python内置函数(#.#)
(2) 变量作用域
在函数内部定义的变量，只在函数内部有效。global语句可以将局部变量声明为全局变量。通过例子来说明：
def egg():
quantity = 108
egg()
print(quantity)
#会报错，不能在函数外部（全局作用域）使用函数内的局部变量
#-------------------------------------------------
quantity = 108
def egg():
print(quantity)
#quantity = 108 也可以在这里定义全局变量
egg()
#函数内的局部作用域，可以访问全局变量
#-------------------------------------------------
def egg():
global quantity
quantity = 108
egg()
print(quantity)
#global语句可以将局部变量声明为全局变量
(3) 自定义函数
定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
自定义一个求绝对值的 my_abs 函数为例：
def my_abs(x):
if x >= 0:
return x
else:
return -x
然后就可以直接调用my_abs()函数了。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。
return None可以简写为return。
(4) 多返回值
有多个返回值时，实际上也是一个单一值，返回值是一个tuple类型！
def xxx():
x = input()
y = input()
return x, y
x, y = xxx() #多个变量可以同时接收一个tuple，按位置赋给对应的值
(5) 默认参数
如前边讲的print()函数有默认参数end。
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面
>>> def xxx(x, y=2):
... print(x,y)
>>> xxx(1) #不传入默认参数时，y按默认设置的值
1 2
>>> xxx(1,1) #传入额外的参数来覆盖默认参数y的值
1 1
(6) 可变参数和关键字参数*args和**kwargs
*args：表示就是将实参中按照位置传值，多余的值都给args，且以元组的方式呈现。
**kwargs：表示就是形参中按照关键字传值，多余的值都给kw，且以字典的方式呈现。
同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，否则会报错。
示例：
def f(x, *args, **kwargs):
x = x
args = args
kw = kwargs
print('x =',x)
print('args =',args)
print('kw =',kw)
print()
f(1, 2, 3)
#x = 1
#args = (2, 3)
#kw = {}
f(0, a=1, b=2, c=3)
#x=0
#args = ()
#kw = {'a': 1, 'b': 2, 'c': 3}
f(0, 1, 2, c=3)
#x=0
#args = (1, 2)
#kw = {'c': 3}
十三、类与对象
这里只大概整理后边爬虫会用到的相关知识。
(1) 定义类、创建实例对象
把具有一类相同属性的对象封装成一个类。在Python中，类通过 class 关键字定义。
按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。创建实例使用 类名+()。
接下来以一个Person类为例：
class Person(object):
address = 'Earth' #类属性
pass
#有了Person类的定义，就可以创建出具体实例
p1 = Person()
p2 = Person()
(2) 初始化实例属性
类有一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用。__init__()方法的**第一个参数必须是 **self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。
class Person(object):
def __init__(self, name, gender, birth):
self.name = name #实例属性name
self.gender = gender #实例属性gender
self.birth = birth #实例属性birth
#相应地，创建实例时，就必须要提供除 self 以外的参数：
p1 = Person('p1', 'Male', '2000-1-1')
p2 = Person('p2', 'Female', '2001-2-2')
#通过'实例对象名.实例属性名'来引用实例属性值
print(p1.name) #输出p1的名字
print(p2.birth) #输出p2的出生日期
区别类属性和实例属性：
绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！
也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份！。
(3) 定义实例方法
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：
class Person(object):
def __init__(self, name):
self.__name = name #以__开头的属性，无法被类外部访问
def get_name(self):
return self.__name
p1 = Person('xiaoming')
print p1.get_name() #self不需要显式传入
#xiaoming
(4) 类的继承
如果已经定义了Person类，现在需要定义新的Student类，而它很多属性和Person都有，所以可以直接从Person类继承，只需要加上新增的属性：
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score #新增的score属性
一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。
函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。
————————每个人都在抱怨生活不易，可是都在默默为生活打拼————————