Python 从入门到项目实践学习笔记（一）

声明：《Python 从入门到项目实践》1-6章节，自学成长记录

Python是一种跨平台、开源的、免费的面向对象的解释型的高级编程语言

Python 版本：

Python 2.x
Python 3.x

Python 的应用领域：

web开发
大数据处理
人工智能
自动化运维
云计算
网络爬虫

Python文件的扩展名：

.py

Python输入：

在Python中，使用内置的input()函数可以接收用户的键盘输入
在Python3.x中，接收到的数据类型为字符串类型，如果想要接收数值，需要进行类型转换

"""
语法格式：
	input(输入内容)
"""
value = input("请输入：")	# value为保存输入结果的变量

Python输出：

在Python中，使用内置的print()函数可以将结果输出到IDLE或者标准控制台上

"""
语法格式：
	print(输出内容)
"""
print(99)						# 输出99
print("China")					# 输出China
print('China', 99)				# 一次性输出China和99,而且不换行
print()							# 空输出并自动化换行
print('China', 100)				# 下一行，输出China 100

注释

在代码中对代码功能进行解释说明的标注性文字，可以提高代码的可读性
注释的内容会被Python解释器忽略，并不会在执行结果中体现出来
在实际开发过程中，只需要对关键代码进行注释就可以了；不必行行都注释

注释的类型:

在Python中，通常包含3中类型的注释，分别是单行注释、多行注释和中文声明注释

# 单行注释
name = 'China'  # 单行注释

'''多行注释'''

"""多行注释"""

编码规范

Python中采用PEP 8作为编码规范

代码缩进

python采用代码缩进和冒号":"区分代码之间的层次
通常采用4个空格作为一个缩进量，也可以采用一个Tab键作为一个缩进量
如果不合理采用代码缩进，将抛出SyntaxError异常

变量

保留字

保留字是Python语言中已经被赋值特殊意义的一些单词
开发程序时，不可以把这些保留字作为变量、函数、类、模块和其他对象的名称来使用
Python中所有保留字是区分字母大小写的

import keyword

print(keyword.kwlist)	# 查看保留字		

标识符

标识符可以简单的理解为一个名字，比如每个人都有名字
标识符主要用来标识变量、函数、类、模块和其他对象的名称
在Python语言中标识符的字母是严格区分大小写的
在Python语言中允许使用汉字作为标识符，但不推荐

变量

在python中，当把一个值赋给一个名字时，称为变量
在Python中，不需要先声明变量名及其类型，直接赋值即可创建各类型的变量

# 变量的定义
变量名 = 变量值

# 使用内置函数type()查看变量类型
type(变量名)

# 使用内置函数id()查看变量内存地址
id(变量名)

基本数据类型

在内存存储的数据可以有多种类型
在Python中，数字类型主要包括整数、浮点数和复数

# 整数-十进制(逢十进一)
2020    # 由0~9组成,不能以0开头(0除外)

# 整数-八进制(逢八进一)
0o123   # 由0~7组成,以0o开头

# 整数-十六进制(逢十六进一)
0Xb01e  # 由0~9 A~F组成,以0x/0X开头

# 整数-二进制(逢二进一)
101	# 只有0和1组成

# 浮点数-由整数和小数部分组成
0.1

# 复数-与数学中的复数形式完全一致
3.14 + 12.5j

在Python中，字符串属于不可变序列，通常使用单引号/双引号或三引号括起来

'单引号字符串'
"双引号字符串"
"""三引号字符串"""

在Python中，布尔类型主要用于表示真或者假的值；其中True表示1，False表示0

Flase或None
数值中的0
空序列
自定义对象的实例

数据类型转换

函数	作用
int(x)	将x转换成整数类型
float(x)	将x转换成浮点数类型
str(x)	将x转换为字符串

运算符

算术运算符

在Python中，算数运算符用来处理四则运算

运算符	描述		实例
+		加		10 + 20 = 30
-		减		10 - 20 = -10
*		乘		10 * 20 = 200
/		除		10 / 20 = 0.5
//		取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
%		取余数	返回除法的余数 9 % 2 = 1
**		幂		又称次方、乘方，2 ** 3 = 8
在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
"-" * 50		输出结果：'----------------------------------------' 

赋值运算符

在 Python 中，使用 = 可以给变量赋值

运算符 	描述 					实例
= 		简单的赋值运算符 		c = a + b 将 a + b 的运算结果赋值为 c
+= 		加法赋值运算符 			c += a 等效于 c = c + a
-= 		减法赋值运算符 			c -= a 等效于 c = c - a
*= 		乘法赋值运算符 			c *= a 等效于 c = c * a
/= 		除法赋值运算符 			c /= a 等效于 c = c / a
//= 	取整除赋值运算符 		c //= a 等效于 c = c // a
%= 		取 模 (余数)赋值运算符 	c %= a 等效于 c = c % a
**= 	幂赋值运算符 			c **= a 等效于 c = c ** a

比较运算符

运算符 	描述
== 		检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
!= 		检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True
> 		检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True
< 		检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True
>= 		检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True
<= 		检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True

逻辑运算符

运算符 	逻辑表达式 	描述
and 	x and y 	只有 x 和 y 的值都为 True，才会返回 True
or 		x or y 		只要 x 或者 y 有一个值为 True，就返回 True
not 	not x 		如果 x 为 True，返回 False

位运算符

位运算是把数字看作二进制数来进行计算的，因此，需要先将执行运算的数据转换为二进制，才能执行位运算
在Python中，位运算有位与( & )、位或( | )、位异或( ^ )、取反( ~ )、左移位( << )、右移位( >> )运算符

运算符的优先级

运算符 		描述
** 			幂 (最高优先级)
* / % // 	乘、除、取余数、取整除
+ - 		加法、减法
<= < > >= 	比较运算符
== != 		等于运算符
= %= /= //= -= += *= **= 	赋值运算符
not or and 	逻辑运算符

序列

在Python中，序列是最基本的数据结构
在Python中，序列结构主要有列表、元组、集合、字典和字符串

索引

序列中每一个元素都有一个编号，也成为索引，通过索引可以访问序列中的任意元素
索引是从0开始递增的，从左向右计算
Python的索引也可以是负数，是从-1开始，即最后一个元素的下标为-1

vars = ['科比', '艾弗森', '麦迪', '卡特']
# 取第一个
print(vars[0])      # 科比
# 取最后一个
print(vars[-1])     # 卡特

切片

切片操作可以访问一定范围内的元素
通过切片操作可以生成一个新的序列

"""
语法格式：
    sname[start：end：step]
参数说明：
    sname:序列的名称
    start:表示切片开始的位置,默认为0
    end:表示切片截止的位置,默认为序列的长度
    step:表示切片的步长，默认为1
"""
citys = ['北京', '上海', '深圳', '广州', '杭州', '重庆']

# 获取城市列表中第2个到第5个元素 
print(citys[1:4])		# ['上海', '深圳', '广州']
# 获取第1/3/5个元素	
print(citys[0:5:2])		# ['北京', '深圳', '杭州']
# 取全部
print(citys[:])      # ['北京', '上海', '深圳', '广州', '杭州', '重庆']
# 列表取反
print(citys[::-1])   # ['重庆', '杭州', '广州', '深圳', '上海', '北京']

序列相加

在Python中，支持两种相同类型的序列相加操作
相同的类型是指同为列表、元组或集合，序列中的元素类型可以不同

# 使用(+)运算符实现序列相加
print(vars + citys) # ['科比', '艾弗森', '麦迪', '卡特', '北京', '上海', '深圳', '广州', '杭州', '重庆']

序列的成员

在Python中，可以使用in关键字检查某个元素是否为序列的成员

"""
语法格式：
    value in values
参数说明：
    value:表示要检查的元素
    values:表示指定的序列
"""
BAT = ['百度', '阿里巴巴', '腾讯']
print("京东" in BAT)    # False

序列的长度 / 最大值 / 最小值

在Python中，使用内置函数len()获取序列的长度
在Python中，使用内置函数max()获取序列中的最大元素
在Python中，使用内置函数min()获取序列中的最小元素

# 定义一个包含8个元素的列表
nums = [1, 55, 33, 4, 66, 9, 100, 18]
# 获取列表nums的长度
print("列表nums的长度为:", len(nums)) # 列表nums的长度为: 8
# 获取列表的最大元素
print("列表nums的最大元素:", max(nums))    # 列表nums的最大元素: 100
# 获取列表的最小元素
print("列表nums的最小元素:", min(nums))    # 列表nums的最小元素: 1

列表

在Python中，列表的所有元素都放在一对中括号"[]“中，两个相邻元素使用逗号”,"分隔
可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中

列表的创建

# 使用赋值运算符直接创建
python = ['优雅', '明确', '简单']
# 创建空列表
empty_list = []
# 创建数值列表
list(range(10, 20, 2))

列表的删除

# 列表的删除
del empty_list

访问列表元素

在Python中，如果想要将列表的内容输出，可以直接使用print()函数

lists = ['python', 30, '人生苦短,我用python', ['爬虫', '自动化运维', 'web开发']]
# 访问列表元素
print(lists[3]) # ['爬虫', '自动化运维', 'web开发']

遍历列表元素

在Python中，遍历列表中的所有元素是常用的一种操作
可以使用for循环 / for循环和enumerate()函数实现

"""
语法格式：
    for item in listname:
        # 对item操作
参数说明：
    item:用于保存获取到的元素值
    listname:表示列表名称
"""

team = ['国家队', '省队', '市队', '校队']
for item in team:
    print(item)

# 输出结果
国家队
省队
市队
校队	

"""
作用：使用for循环和enumerate()函数可以实现输出列表索引值和元素内容
语法格式：
    for index,item in enumerate(listname):
        # 对index,item操作
参数说明：
    index:用于保存元素的索引
    item:用于保存获取到的元素值
    listname:表示列表名称
"""

team = ['国家队', '省队', '市队', '校队']
for index, item in enumerate(team):
    print(index, item)
   
# 输出结果
0 国家队
1 省队
2 市队
3 校队

更新列表元素

在Python中，添加、修改和删除列表元素都是对列表的更新操作

"""
append()：用于在列表的末尾追加元素
语法格式：
    listname.append(obj)
"""
phone = ['华为', '小米', 'OPPO']
phone.append('vivo')
print(phone)    # ['华为', '小米', 'OPPO', 'vivo']

"""
insert()：用于向列表的指定位置插入元素
语法格式：
    listname.insert(obj)
"""
phone.insert(0, '大哥大')
print(phone)    # ['大哥大', '华为', '小米', 'OPPO', 'vivo']

"""
extend()：用于想列表中添加另外一个列表
语法格式：
    listname.extend(seq)
参数说明：
    seq:会将列表seq的内容追加到列表listname的后面
返回值：
    该方法没有返回值，但会在已存在的列表中添加新的列表内容
"""
list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a.extend(list_b)
print(list_a)   # [1, 2, 3, 4, 5, 6]

"""
修改列表元素：通过索引获取到元素后为其重新赋值即可
"""
list_u = [11, 22, 33]
list_u[2] = 55
print(list_u)   # [11, 22, 55]

"""
删除列表元素：根据索引删除 / 根据元素值删除
"""
list_d = [1, 2, 3]
del list_d[2]   # 根据索引
print(list_d)   # [1, 2]

if 1 in list_d:         # 判断是否存在
    list_d.remove(1)    # 根据元素值
print(list_d)   # print(list_d)

对列表进行统计

在Python中，列表内置函数可以实现统计、计算方便的功能

"""
count():获取列表中指定元素出现的次数
语法格式:
    listname.count(obj)
"""
list_count = [11, 12, 11, 11, 15]
print(list_count.count(11))     # 3

"""
index():获取列表中指定元素首次出现的下标
语法格式:
    listname.index(obj)
"""
list_count = [11, 12, 11, 11, 15]
print(list_count.index(11))     # 0

"""
sum():统计数值列表中各个元素的和
语法格式:
    sum(listname[,start])
参数说明:
    start:可选参数,默认为0,表示统计结果从哪个数开始
"""
list_s = [11, 22, 33, 44, 55]
print(sum(list_s, 6))     # 171(165 + 6)

对列表进行排序

在Python中，可以使用列表对象的sort()方法和使用内置函数sorted()函数对列表进行排序

"""
sort():对原列表中的列表元素进行排序
语法格式:
    listname.sort(key=None, reverse=False)
参数说明:
    key:接受的是一个只有一个形参的函数
    reverse:排序规则;True为降序,False升序(默认)
返回值:
    该方法没有返回值
"""
list_sort = [11, 44, 33, 22, 55]
list_sort.sort(reverse=True)
print(list_sort)    # [55, 44, 33, 22, 11]

"""
sorted():对列表元素进行排序,不会改变原列表的排列顺序
语法格式:
    sorted(listname, key=None, reverse=False)
参数说明:
    key:接受的是一个只有一个形参的函数
    reverse:排序规则;True为降序,False升序(默认)
"""
list_sorted = [11, 44, 33, 22, 55]
new_list_sorted = sorted(list_sorted, reverse=True)  # 生成一个新的排序好的列表
print(list_sorted)      # [11, 44, 33, 22, 55] 原列表
print(new_list_sorted)  # [55, 44, 33, 22, 11] 

列表推导式

在Python中，可以使用列表推导式可以快速的生成一个列表，或根据某个列表生成满足指定需求的列表

"""
语法格式:
    newlist = [Expression for var in list if condition]
参数说明:
    newlist:表示新生成的列表名称
    Expression:表达式,用于计算新列表的元素
    var:变量,值为后面里列表的每个元素值
    list:原列表
    condition:条件表达式
"""
import random
# 生成一个10个随机数的列表（10~100）
list_l = [random.randint(10, 100) for i in range(10)]
print(list_l)	# [82, 66, 55, 53, 69, 53, 77, 65, 15, 10]

# 根据列表生成指定需求的列表
new_list = [int(x * 0.8) for x in list_l]
print(new_list)	# [65, 52, 44, 42, 55, 42, 61, 52, 12, 8]

# 从列表中选择符合条件的元组组成新的列表
newlist = [ii for ii in list_l if ii > 60]
print(newlist)  # [77, 74, 89]
print(type(new_list))   # <class 'list'>

元组

在Python中，列表的所有元素都放在一对括号"()“中，两个相邻元素使用逗号”,"分隔
可以将整数、实数、字符串、列表、元组等任何类型的内容放入到元组中
在实际开发中，通常用于保存程序中不可修改的内容

元组的创建

# 创建空元祖
empty_tuple = ()
print(type(empty_tuple))    # <class 'tuple'>

# 创建数值元组
tuple_r = tuple(range(10, 15))
print(tuple_r)          # (10, 11, 12, 13, 14)
print(type(tuple_r))    # <class 'tuple'>

元组的删除

del语句在实际开发中并不常用，因为Python自带的垃圾回收机制会自动销毁不用的元组

# 删除元组
del tuple_r 

访问元组元素

# 访问元组元素
BAT = ('百度', '阿里', '腾讯')
print(BAT[1])   # 阿里

修改元组元素

在Python中，元组是不可改变序列，所以不能对它的单个元素进行修改
可以对元组进行重新赋值或对元组进行连接组合从而达到修改元组元素的目的

# 重新赋值
BAT = ('百度', '阿里', '腾讯')
BAT = ('baidu', 'ali', 'tengxun')
print(BAT)  # ('baidu', 'ali', 'tengxun')

# 元组连接
print(('北京', '上海') + ('中国',))
# 注意：如果要连接的元组只有一个元素，不要忘记后面的逗号

元组推导式

在Python中，使用元组推导式生成的结果不是一个元组，而是一个生成器对象，需要将其转换成元组

# 使用元组推导式生成的结果是一个生成器对象
numbers = (i for i in range(1, 6))
print(type(numbers))    # <class 'generator'>
print(numbers.__next__())   # 1
print(numbers.__next__())   # 2
print(numbers.__next__())   # 3
numbers = tuple(numbers)    
print(type(numbers))        # <class 'tuple'>
print(numbers)              # (4, 5)

列表和元组的区别

列表属于可变序列，元组属于不可变序列
列表可以使用append()、extend()、insert()、remove()、pop()等方法实现对元素的操作，元组则没有这几个方法
列表可以使用切片访问和修改列表中的元素，元组只支持切片访问元素，不支持修改
元组比列表的访问和处理速度快
列表不能作为字典的键，而元组则可以