Python编程从入门到实践

第1章 安装Python

第2章 变量和简单数据类型

2.0 python语法基础

//单行注释
多行注释可以用多个 # 号，还有 '''(三单引号) 和 """(三双引号)
打印时三引号可以保留文本的格式

如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
a = b = c = d = 1

A = a + b + \
    c + \
    d

type() 查看变量类型
isinstance(变量，类型) --> bool

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

（Python3 中，bool 是 int 的子类，
True 和 False 可以和数字相加， True==1、False==0 会返回 True，
但可以通过 is 来判断类型。
1 is True --> False）

del var1,var2,[var3[....,varN]]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.1变量的命名与使用

1. 变量名只能包含字母、数字、下划线_ ；变量名只能以字母或者下划线打头，不能以数字开头
2. 变量名不能包含空格，可以使用下划线来分割单词
3. 关键字和函数名不能用作变量名
4. 变量名应该简短且具有描述性；大写字母应该慎用

2.2 字符串

字符串就是一系列的字符，单引号或者双引号括起来的都是字符串（以此来区分引号和撇号）

- 空格也算一个字符
- Python 中单引号 ' 和双引号 " 使用完全相同。
- 使用三引号(''' 或 """)可以指定一个多行字符串。
- 转义符 \。
- 反斜杠可以用来转义，使用 **r** 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n会显示，并不是换行。
- 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string。 
- 字符串可以用 + 运算符连接在一起，用 * n运算符重复字符串n次。
- Python 中的字符串不能改变。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]，从头下标字符开始，不包含尾下标那个字符
- Python 中的字符串有两种索引方式，从左往右以 0开始，从右往左以 -1 开始
1
2
3
4
5
6
7
8
9
10
11

2.2.1 关于字符串的一些方法

变量名.title()   字符串首字母大写
		  .upper()  全部大写
		  .lower() 全部小写
		  
使用 + 来拼接字符串
 
 \t 制表符 
 \n 换行
 
删除字符串两端空格:
 
字符串.rstrip()  删除字符串右边空格；这种删除只是暂时的，若要永久保存要将删除结果存回到变量中	
字符串.lstrip()  删除左空格
字符串.strip()  删除两边的空格
.stripe('a') 删除指定字符

.replace('a','b')  将字符串中的a替换为b，包括任意符号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2.2 格式化字符串

a = 1
b = 1.2
 1.format()
# 1.1 使用索引来获取字符串中的字符
string1 = "a的值为{0}，b的值为{1:.1f}".format(a, b)
print(string1)

# 1.2 使用关键字参数来获取字符串中的字符
string2 = "a的值为{a}，b的值为{b:.2f}".format(a=a, b=b)
print(string2)

# 1.3 locals()函数返回一个包含当前局部变量的字典，然后使用format()函数将这些变量的值插入到字符串中。{}内的a和b表示要插入的变量名，{}内的{}表示要插入的变量值。
string3 = "a的值为{a}，b的值为{b:.3f}".format(**locals())
print(string3)

 2.f-string
# 字符串中使用f-string来获取字符串中的字符
string = f"a的值为{a}，b的值为{b:.4f}"
print(string)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.3 数字

** 表示乘方运算

str()  	将非字符串表示为字符串
int()  	将字符串表示为整型数字
float() 将字符串表示为浮点型数字

/ 返回一个浮点数，
// 返回一个整数,向下取整
math.floor(1 / 2)	-> 0  向下取整
math.ceil(1 / 2)	-> 1  向上取整

注释：用#来标识
1
2
3
4
5
6
7
8
9
10
11
12

第3章 列表

3.1列表

列表：由一系列按特定顺序排列的元素组成     

letters = ['a','b','c']

列表名称最好用复数的名称，如：names,digits 

列表内的元素是从0开始排序的，元素所在位置称为索引
letters[0] ——'a'  letters[2] ——'c'
letters[-1] ——'c'  letters[-2] ——'b'
1
2
3
4
5
6
7
8
9

3.2修改列表元素

letters[1] = '1'  ——> letters = ['a','1','c']

letters.append('d')   将元素附加到**列表末尾**
——> letters = ['a','1','c','d']

letters.insert(1,'b') ——> letters = ['a','b','1','c','d']  		根据提供的索引与值，将值插入到该索引中。（该方法将索引后的元素都右移了一个位置）

**del** letters[2]   删除索引位置为2的元素并**不再使用**

**pop** = letters.pop(索引)   弹出索引位置的元素,保存到 新变量中**继续使用**，如没提供索引值，则默认弹出最后一个元素

letters.remove(值)  根据值来删除元素（不会删除所有的这个值，只会删除第一个指定的值）
1
2
3
4
5
6
7
8
9
10
11
12

3.3组织列表

letters.sort()  列表中的元素按字母顺序排序（永久性改变顺序）
letters.sort(reverse=True)  相反的字母顺序排序（永久性改变）

可利用方法
sorted(letters)   	临时的按字母的顺序显示列表

letters.reverse()	反转列表元素的排列顺序，也是永久性的改变

len(letters) 		确定列表的长度
1
2
3
4
5
6
7
8
9

第4章 操作列表

names = ['a','b','c']

遍历列表：  
for name in names**：**
	print(name)  #循环部分需要缩进

函数range():
for value in range(1,6,2):
	print(value)
1
2
3
4
5
6
7
8
9

输出：1 3 5

range()函数从第一个数字开始到第二个数字为止（不包括第二个数字）生成一系列的数字，第三个参数为步长（可以此来生成奇偶数）

函数list()可以将一些结果直接转换为列表
如利用range()函数生成一个数字列表：
	numbers = list(range(1,5))
	print(numbers)
1
2
3
4
5
6

求数字列表 最小值min() 最大值max() 总和sum()

列表解析
numbers = [value**2  for value in range(1,11)]  #第一个表达式用于生成所需要的值，后面的for循环为表达式的计算提供值
print(numbers)
1
2
3

输出：[1,4,9,16,25,36,49,64,81,100]

切片：列表的部分元素
numbers = ['a','b','c','d']
print(numbers[1:3]) #若没有指定第一个索引，则默认从列表开头开始，同理若没指定终止索引，则默认到列表末尾为止（负数索引同样也适用，[-3:-2]结果相同）
1
2
3

输出：[‘b’,‘c’]

复制列表可以省略起始索引和终止索引，则可获得一个与原列表相同的新列表 [:]

元组：即不可修改的列表，使用圆括号来表示
如numbers = (0,1,2) 元组的元素是不可修改的，修改元组将会报错
但是，可以给存储元组的**变量**赋值（numbers = （'a','b','c'）这个是可以的）
1
2
3

第5章 if语句

if 条件测试（返回结果必须为True或False）:  
#一个=是陈述：赋值; 两个等号==是发问：是否相等; 不相等 !=
	_______
elif 条件测试:  # elif代码块可根据需要使用任意数量
	_______
。。。
else:  #else代码块可以省略的
	————
函数lower() 可将变量的值转换为小写，但不会修改变量的值

 A and B：A和B都T才T，一个F都F
 A or B ： A和B一个T便T，两个都F才F

关键字in ：可以判断特定的值是否包含在列表中 # A in letters
     not in： 可以判断特定的值是否不包含在列表中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第6章 字典

字典是一系列键值对，每个键都与一个值相关联，你可以使用键来访问与之相关联的值。（值可以是数字、字符串、列表乃至字典）

d = {key1 : value1, key2 : value2, key3 : value3 }

访问字典的值： d[key1] --> value1

添加键值对： 字典是一种动态结构，可以随时在其中添加键值对

d[key4] = value4   
d[key5] = value5
-->
d = {key1 : value1, key2 : value2, key3 : value3 , key5 : value5, key4 : value4 }
**键值对的排列顺序与添加顺序不同**，python不关心键值对的添加顺序，只关心键和值的关系

修改字典中的值： 
	d[key4] = value6 
	--> d = {key1 : value1, key2 : value2, key3 : value3 , key5 : value5, key4 : value6 }

删除键值对：
 del d[key4] --> d = {key1 : value1, key2 : value2, key3 : value3 , key5 : value5 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

遍历字典：
for key, value in d.items(): // .items() 函数以列表形式返回所有可遍历的(键, 值) 元组数组
print(“\nkey:” + key)
print(“value:” + value)

-->
key: key1
value: value1

key: key2
value: value2

key: key3
value: value3

key: key5
value: value5
1
2
3
4
5
6
7
8
9
10
11
12

遍历字典中的所有键：
for key in d.keys(): // .keys()提取所有的键（返回一个包含所有键的列表）遍历字典时，会默认遍历所有的键，所以这里的keys() 函数可有可无
print(key)

--> 
key1
key3
key2
key5	
1
2
3
4
5

sorted() 函数会以字母的顺序返回值

遍历字典中的所有值： 
	.values() 返回一个包含所有值的列表
	集合set()  去除重复项
1
2
3

嵌套

嵌套：将字典存储在列表中，或者将列表作为值存储在字典中，也可将字典存储在字典中
定义三个字典： 
	d1 = {}
	d2 = {}
	d3 = {}
将字典存储在列表中：
	ds = [d1, d2, d3]

当需要在字典中将**一个键关联到多个值**时，可以在字典中嵌套一个列表

d = {key1 : {key2 : value2}}  字典中嵌套字典
1
2
3
4
5
6
7
8
9
10
11

第7章 用户输入与while 循环

input() 返回的值是字符串！

第8章 函数

形参：函数定义时的参数
实参：调用函数时传递给函数的参数

def greet_user0(username): # 这里的username就是一个形参
	"""文档字符串"""  # 描述文档做什么，用三引号表示
	print(username)


greet_user0('sun') # 参数sun就是实参
1
2
3
4
5
6

位置实参：调用函数时每个实参都要关联到形参，要求实参的顺序与形参相同

def greet_user1(name,address):
    """位置实参"""
    print('Hello,'+ name)
    print('where are you?' + address)


greet_user1('sun','sichuan') #位置实参，要求顺序一致
1
2
3
4
5
6
7

关键字实参：传递给函数的名称——值对

greet_user1(address='bazhong',name='sun')  #采用关键词实参，实参的顺序便不重要了，关键是参数名字要准确
1

形参默认值：在定义函数时，可给每个形参指定默认值，在函数调用时若未给出实参，则会使用默认值

def greet_user2(name,address='sichuan'): #这里默认值等号两边不要有空格
    """默认值"""
    print('Hello,'+ name)
    print('where are you?' + address)
    
greet_user2('sun') #结果，默认地址为sichuan
  但要注意，这里任然视作位置实参，所以形参的位置顺序要注意。
  
greet_user2('sun','bazhong')
  在使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参，这样才能正确解读位置实参
1
2
3
4
5
6
7
8
9
10

函数的返回值可以返回任何类型的值，包括列表、字典等复杂的数据结构。
使用return语句将值返回给调用函数的代码行

每个函数都应只负责一项具体的工作
可利用函数修改列表，这种对列表的修改是永久性的
若想禁止函数修改列表，可向函数传递副本。切片表示法[:]：创建列表的副本

传递任意数量的实参
（星号*）的作用：创建一个空元祖。 在提前不知道函数需要接受多少个实参时，可利用*创建一个空元组，来接受任意数量的实参
（**）的作用：创建一个空字典
1
2
3
4
5
6
7

import 语句可以在当前运行的程序文件中使用模块中的代码
模块：扩展名为.py的独立文件

pizza.py

def make_pizza(size,*toppings):
    """概述要制作的披萨"""
    print("\nMaking a " + str(size) +
          "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

1
2
3
4
5
6
7

making_pizzas.py

import pizza #导入模块pizza
pizza.make_pizza(16, "pepperoni") #使用模块pizza
pizza.make_pizza(12,'mushroom','green peppers','extra cheese')
1
2
3

导入模块中任意数量的特定函数：
 from 模块名 import fun_1, fun_2, fun_3....
在调用这些函数时就不需要使用句点.了，直接使用函数即可

使用关键字as给函数指定别名：
例如给函数make_pizza()指定别名为mp： from pizza import make_pizza as mp
在调用函数make_pizza()时便可以直接使用mp名来调用，mp()

也可使用关键字as给模块指定别名：
 import pizza as p
 p.make_pizza()

 (*）可以导入模块中所有函数
 from pizza import *  导入了所有函数，所以在调用时，不用使用句点表示法来调用了
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在编写函数时应该注意：
1.函数名应该只包括小写字母和下划线
2.形参指定默认值和使用关键字实参时，等号两边不要有空格
3.import语句应该放在文件开头

第9章 类

class TestClass(Dad): //Dad是继承的父类
	//__init__() :类中的一个特殊方法叫构造函数，定义对象的属性
	def __init__(self,a_name,b_age,c_sex...):
		super().__init__(a,b,c) //调用父类Dad的属性
		//self,是为了将属性的值绑定在实例对象上
		self.name = a_name //这样说明a_name是该对象的name属性的值
		//如果写成 name = a_name 它会认为你是在给普通name变量赋值，就不会认为是其属性的值
		self.age = b_age
		self.sex = c_sex
		
	def method1(self): //这里的self是为了调用构造函数中定义的属性。
		print(self.name)
		
	def method2(self,content): //这里的self是为了调用构造函数中定义的属性。
		print(f"{self.age}岁，{content}")

	def method3(self): //这里的self是为了调用构造函数中定义的属性。
		print(self.sex)

#实例化类：
class1 = TestClass("azheng",24,"男")
print(f"class1的名字是{class1.name}，年龄是{class1.age}岁，性别{class1.sex}")
class1.method1()
class1.method2("花一样的年纪！！！")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第10章 文件操作

注意: windows下，分隔符是反斜杠\ ; linux 下是斜杠/
绝对路径：C:\windows\system32\cmd.exe
相对路径：.\cmd.exe

#打开并读文件
f = open("./data.txt","r",encoding="utf-8")
print(f.read()) # 会读取全部的文件内容
print(f.read()) # 会读取空的字符串，因为上一个read()已经读到文件末尾了

print(f.read(10)) #会读取10个字节的文件内容
print(f.read(12)) #接着上次的读取后面的12个字节的文件内容

print(f.readline()) #会读取一行文件内容
print(f.readline()) #会接着读取下一行的文件内容

print(f.readlines()) #返回全部的文件内容组成的列表，包括换行符

#关闭文件
f.close() #每次打开文件读取结束后，都应该关闭文件

#文件读取结束后，会自动关闭文件
with open("./data.txt") as f:  
	print(f.read(()) 

#写文件
//读写参数的区别

r’：只读模式
只读，不可写。打开时光标自动定位到开头位置。

‘w’：只写模式
只写，不可读。打开时自动清空原文档。

‘a’：追加模式
只写，不可读。打开时不清空原文档，光标自动定位到文档末尾。

‘r+’：读写模式
先读后写。打开文档时不清空原内容，光标定位正在开始位置。读完后光标会移到文档末尾，所以写的时候是追加在文档最后的。不会覆盖原内容。
如果以“r+”模式打开，但是先写后读，那么写入的内容会覆盖原内容，读取时从写结束位置开始读。

‘w+’：写读模式
先写后读。打开文档即清空原内容，从文档开头写起，写完后光标自动移到文档末尾，此时进行读取，内容为空。需要将光标移到首位，f.seek(0)。
如果以“w+”模式打开，先进行读操作，读到的内容也是为空，因为打开即被清空了。

‘a+’：追加写读模式
先写后读。追加在原文档末尾，不会清空原内容，写完后光标移到文档末尾，此时进行读取，内容为空。需要将光标移到首位，f.seek(0)。
如果以“a+”模式打开，先进行读操作，读到的内容也是为空，因为打开即把光标定位在文档末尾。

with open("./data.txt","w",encoding="utf-8") as f:   //当文件不存在时，会自动创建
	f.write("123")
	print(f.read(()) // w模式下，读取文件会报错 
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
51

第11章 异常处理

try:
	正常程序代码
except 错误类型1:
	报类型1错误时，执行的内容
except 错误类型2:
	报类型2错误时，执行的内容
except :
	报其他类型错误时，执行的内容
else:
	没有发生错误时，执行的内容
finally:
	不管错误与否，都会执行的
1
2
3
4
5
6
7
8
9
10
11
12

第12章 测试

assert 1==1 #断言，判断是否为True,发生错误时，程序停止运行

assertEqual(a,b) -->  assert a==b
assertTrue(a) 	 -->  assert a is True

import unittest #单元测试
1
2
3
4
5
6

第二部分 项目实战

1. 外星人大战

不能传文件… 0.0

2. Web 应用程序

1.在迁移第二个模型时，出现报错：

TypeError: __init__() missing 1 required positional argument: 'on_delete'
1

处理方法：在关联外键Topic 处，添加 on_delete=models.DO_NOTHING, # 删除关联数据,什么也不做

topic = models.ForeignKey(Topic, on_delete=models.DO_NOTHING)
1

2.在映射URL中遇到错误：

django.core.exceptions.ImproperlyConfigured: Passing a 3-tuple to include() is not supported. Pass a 2-tuple containing the list of patterns and app_name, and provide the namespace argument to include() instead.
1

问题出在：

from django.conf.urls import include, url
from django.contrib import admin
 
urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'', include('learning_logs.urls', namespace='learning_logs')),
]
1
2
3
4
5
6
7

Django的版本号不一样，所以这里需要更改

from django.conf.urls import include, url
from django.contrib import admin
 
urlpatterns = [
    url(r'^admin/', admin.site.urls), #不用include()函数
    url(r'', include(('learning_logs.urls','learning_logs'), namespace='learning_logs')),
]
1
2
3
4
5
6
7

3.在19.1.1添加新主题中编写视图函数new_topic()时遇到No module named 'django.core.urlresolvers’错误

 是因为django更新后的改变，即django2.0开始的版本把 django.core.urlresolvers 包 更改为了 django.urls包
所以需要把 from django.core.urlresolvers import reverse
修改为 from django.urls import reverse
1
2
3

3. python爬虫

3.1 获取网页内容

通过HTTP获取网页内容，HTTP是客户端与服务器之间的响应协议

HTTP请求方法：
GET方法：获得数据
POST方法：创建数据，比如提交登陆框的账号密码等表单信息

python 安装requests库：pip install requests

response = requests.get("https://books.toscrape.com/",headers = head) 
head = {"User-Agent":" ","XFF":" "} //需要更改的请求头字典
print(response) 返回的是响应Response实例
print(response.status_code) 返回的是HTTP状态码
print(response.ok)   返回True，说明请求成功
print(response.text)   返回响应体的内容

requests.post()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2 解析网页内容

BeautifulSoup : HTML解析
库安装：pip install bs4
从库bs4中引入BeautifulSoup这个类
from bs4 import BeartifulSoup

response = requests.get("https://books.toscrape.com/",headers = head) .text
soup = BeautifulSoup(response,"html.parser") //调用html解析器

all_prices = soup.findAll("p",attrs={"class":"price_color"}) 
//findAll函数查找p标签，元素属性为price_color的类，并返回可迭代的对象
//findAll() 和 find_all() 用法完全相同

for price in all_prices:
	print(price.string) //price是对象属性，我们可以只打印它的字符串，就可得到对象中的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.3 存储或分析数据