Python 学习笔记

最新推荐文章于 2024-09-15 22:31:42 发布

trw777

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量335

点赞数 1

分类专栏： Python 文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/trw777/article/details/126825581

版权

Python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Python 学习笔记

python基础

Python标识符

Python 标识符由字母、数字、下划线组成。

所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

标识符区分大小写

a = 1
_b2 = 2
# 标识符不能为 2_int = 3

代码注释

单行注释在行首添加 # 号

# 此行为单行注释

多行注释在需要注释的内容前后添加'''或"""

""" 
此处为多行注释
访问http
pip install -i https://mirrors.aliyun.com/pypi/simple/ requests
pip install -i https://mirrors.aliyun.com/pypi/simple/ wheel
pip install -i https://mirrors.aliyun.com/pypi/simple/ beautifulsoup4

解析html
pip install -i https://mirrors.aliyun.com/pypi/simple/ bs4
pip install -i https://mirrors.aliyun.com/pypi/simple/ lxml

处理电子表格
pip install -i https://mirrors.aliyun.com/pypi/simple/ openpyxl

打包程序
pip install -i https://mirrors.aliyun.com/pypi/simple/ pyinstaller

镜像源使用阿里源 
"""

行与缩进

python代码块的层次是已缩进来区分的，每一层此的缩进长度可以变化，但一定要保持一直。

当一条命令过长或是为了保持整洁型，需要换行时，我们需要用到续行符 \ 。当语句在() ,[], {}中时不需要转义字符\。

当一行书写多条命令时，命令与命令之间要用分号;隔开。

Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

关键字	描述	关键字	描述	关键字	描述
and	逻辑运算与	exec	调取py文件	not	布尔取反
assert	运行失败执行	finally	try后总是执行	or	逻辑运算或
break	跳出整个循环	for	循环语句	pass	空语句
class	定义类对象	from	从库中导入部分	print	打印输出
continue	跳出本次循环	global	全局作用域	raise	抛出自定义异常
def	定义函数	if	条件语句	return	函数返回对象
del	删除列表元素	import	导入库	try	处理异常
elif	配合if使用，	in	for i in {1…2}	while	循环
else	for,while,try无异常结束后运行	is	是否同一对象	with
except	捕获所有异常	lambda	匿名函数	yield
False	假	True	真	None	空

数据类型

基本数据类型

整数

int：为整数型

>>> int0 = 2
>>> int0
2
>>> type(int0)
<class 'int'>
>>> print(int0)
2

浮点数

float：为浮点型变量，带有小数点的数字

>>> float0 = 3.0
>>> float0
3.0
>>> type(float0)
<class 'float'>
>>> print(float0)
3.0

字符串

str：为字符串，一个或多个任意字符组成的一串集合。

>>> str0 = '你好'
>>> str0
'你好'
>>> type(str0)
<class 'str'>
>>> print(str0)
你好
>>>

布尔

bool：为布尔类型变量，变量只有：Trun和Fales，在判断语句循环语句中使用来判断运行条件是否满足。

# 定义变量为假，可以用 : 
>>> bool1 = False
>>> bool1
False
>>> type(bool1)
<class 'bool'>
>>> print(bool1)
False

# 定义变量为真：
>>> bool5 = True
>>> bool5
True
>>> type(bool5)
<class 'bool'>
>>> print(b)
True

数据之间相互转换

不同数据类型之间是可以相互转换的。程序运行计算过程中，有些数据可以自动转换类型，C语言中叫做隐形转换。有些运算需要进行强制转换。

int() 数据转换成整数函数

可以把可以把整数，浮点数，字符串，布尔数转换为整数。

# 整数转换为整数
int0 = 11
int1 = int(int0)
print(type(int1))
print(int1)

# 浮点数转换为整数
float0 = 12
int2 = int(float0)
print(type(int2))
print(int2)

# 数字字符串转换为整数
str0 = 13
int3 = int(str0)
print(type(int3))
print(int3)

# 布尔型换为整数 ，只有 0 和 1
bool0 = False
int4 = int(bool0)
print(type(int4))
print(int4)

# 还可以把不同进制的数字转换为10进制
print(int(1011,2))
print(int(12,8))
print(int(13,10))
print(int(14,16))

float() 数据转换成整数函数

可以把可以把整数，浮点数，字符串，布尔数转换为整数。

# 整数转换为浮点数
int0 = 11
int1 =  float(int0)
print(type(int1))
print(int1)

# 浮点数转换为浮点数
float0 = 12.2
int2 =  float(float0)
print(type(int2))
print(int2)

# 数字字符串转换为浮点数
str0 = '13.3'
int3 =  float(str0)
print(type(int3))
print(int3)

# 布尔型换为整数 ，只有 0 和 1
bool0 = False
int4 =  float(bool0)
print(type(int4))
print(int4)

str() 数据转换成字符串函数

可以把可以把整数，浮点数，字符串，布尔数转换为字符串。

# 整数转换为字符串
int0 = 11
int1 = str(int0)
print(type(int1))
print(int1)

# 浮点数转换为字符串
float0 = 12.2
int2 = str(float0)
print(type(int2))
print(int2)

# 数字字符串转换为字符串
str0 = '13.3'
int3 = str(str0)
print(type(int3))
print(int3)

# 布尔型换为字符串 ，只有 0 和 1
bool0 = False
int4 = str(bool0)
print(type(int4))
print(int4)

bool() 数据转换成布尔函数

可以把整数、浮点数、字符串、列表、元组、字典、None转换为布尔型。

当bool() 函数传入的参数为 (0 | 0.0 | ‘’ | [] | () | {} |None) 时，返回值为False ,其他则返回为真。

# 整数转换为字符串
int0 = 0
int1 = bool(int0)
print(type(int1))
print(int1)

# 浮点数转换为字符串
float0 = 0.0
int2 = bool(float0)
print(type(int2))
print(int2)

# 数字字符串转换为字符串
str0 = ''
int3 = bool(str0)
print(type(int3))
print(int3)

# 布尔型换为字符串 ，只有 0 和 1
bool0 = False
int4 = bool(bool0)
print(type(int4))
print(int4)

数据结构

除了基本数据类型外，python 还有通过多个基本数据类型组合而成的数据结构类型：列表、元组、字典。

列表

list 列表时有多个基础数据类型集合成一个组，组内每个成员可以是同一类型，也可以是不同类型。组内成员可以增加，也可以减少。每个成员称之为列表的一个元素，每个元素按照顺序有一个自己的编号，叫做索引，索引是从数字0 开始。我可以通过列表名加索引的方式来对元素进行增删改查等操作。

创建列表

# 以方括号标识，每个元素使用逗号隔开
>>> list0 = [1, 'a', 1.1, True]
>>> list0                       
[1, 'a', 1.1, True]
>>> print(list0)                
[1, 'a', 1.1, True]

列表的读取

# 直接使用列表名，可以读取列表所有元素
>>> print(list0)                
[1, 'a', 1.1, True]
#1   2    3    4	表示第几个元素
#0   1    2    3	表示索引编号
#-4  -3   -2   -1	表示索引编号为负数

# 使用列表名加索引，可以访问可以访问第n+1个元素，索引3即为第四个元素，数字为负数的为从右往左数
>>> print(list0[3])
True

#我们也可以读取列白的某一个连续区域，选在区域取值是为左闭右开模式，左边包含边界值，右边不包含边界值。
#如果左边从开头开始，0 可忽略不屑，如果右边到结束，结尾数字也可或略不写。
>>> print(list0[1:3]) 
True
>>> print(list0[0:])  
[1, 'a', 1.1, True]
>>> print(list0[:-1]) 
[1, 'a', 1.1]
>>> print(list0[:4])  
[1, 'a', 1.1, True]

列表的插入修改

# 列表的尾部追加
>>> list0 = [1, 'a', 1.1, True]
>>> list0.append('ok')
>>> list0
[1, 'a', 1.1, True, 'ok']

# 指定位置插入，方法insert，第一个参数为索引位置，第二个参数为插入的元素值。
>>> list0 = [1, 'a', 1.1, True]
>>> list0.insert(1,'start')
>>> list0
[1, 'start', 'a', 1.1, True]

# 列表的链接，加号可以对两个列表进行连接赋值给自己
>>> list0 = [1, 'a', 1.1, True]
>>> list0 = list0+[3,5,6] 
>>> list0                
[1, 'a', 1.1, True, 3, 5, 6]

# 指定位置修改
>>> list0 = [1, 'a', 1.1, True]     
>>> list0[1] = 'b' 
>>> list0
[1, 'b', 1.1, True]

# 连续区域修改
>>> list0 = [1, 'a', 1.1, True]  
>>> list0[1:4] = ['b','c','d']    
>>> list0                         
[1, 'b', 'c', 'd']

列表的删除

# 删除列表单个元素
>>> list0 = [1, 'a', 1.1, True]
  # 使用del函数删除
>>> del(list0[3]) 
>>> print(list0) 
[1, 'a', 1.1]
  # 使用列表remove方法删除
>>> list0.remove('a') 
>>> print(list0)      
[1, 1.1]
  # 尾部删除
>>> list0.pop()
1.1
>>> print(list0)
[1]
>>>

# 删除列表某个区域
  # 使用del函数删除
>>> del(list0[1:3])             
>>> print(list0)                
[1, True]

# 删除全部元素
>>> list0 = [1, 'a', 1.1, True]
>>> del(list0[:])              
>>> print(list0)                
[]

#删除列表变量,变量会被释放，在读取是会提示变量不存在。
>>> del[list1]
>>> print(list0) 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list0' is not defined

#del[list0[:]] 与 del(list0) 效果是不一样的，前者只是把每个元素删除，但变量还存在

列表常用函数

列表常用函数有：max(list) 取最大值、min(list) 取最小值、len(list) 获取列表元素个数、list.sort 对列表进行排序、sorted(list) 把列表值取出后进行排序，不修改源列表

# max() 获取最大值 ，字符串只能和字符串之间求最大值。
>>> list0 = ['b', 'a', 'd', 'e']  
>>> max(list0)                   
'e'
>>> list0 = [1, 2, 3.4, True]     
>>> max(list0)                
3.4

# min() 获取最大值 ，字符串只能和字符串之间求最大值。
>>> lists = ['b', 'a', 'd', 'e']  
>>> min(lists)                     
'a'
>>> listi = [1, 2, 3.4, False]   
>>> min(listi)                   
False

# len() 获取列表元素个数
>>> list0 = [1, 'a', 1.1, True]
>>> len(list0) 
4

# 列表排序
>>> lists = ['b', 'a', 'd', 'e']  
>>> lists.sort()
>>> lists
['a', 'b', 'd', 'e']

>>> listi = [1, 4, 1.1, True]
>>> listi.sort()                
>>> listi                       
[1, True, 1.1, 4]

>>> listi = [1, 4, 1.1, True]
>>> sorted(listi) 
[1, True, 1.1, 4]
>>> listi        
[1, 4, 1.1, True]

列表的拷贝

>>> list1 = [1,2,3,4,5] 
>>> list2=list1
>>> list1
[1, 2, 3, 4, 5]
>>> list2
[1, 2, 3, 4, 5]
>>> list2[2] = 10
>>> list1    
[1, 2, 10, 4, 5]
>>> list2
[1, 2, 10, 4, 5]
>>> list1[2]=9
>>> list1      
[1, 2, 9, 4, 5]
>>> list2         
[1, 2, 9, 4, 5]

列表变量 list2 直接等于 list1 只是把list2 指向了list1 的数据内存位置，就像C语言中的内存指针，他们使用的的是同一块内存。而非是新建了一个列表变量，要想新建一个有独立数据的list2变量，我们需要先把list1的元素数据提取出来，复制给list2,而非把list1列表对象直接给list2.

>>> list1 = [1,2,3,4,5] 
>>> list2=list1[:]
>>> list2
[1, 'a', 1.1, True]
>>> list1
[1, 'a', 1.1, True]
>>> list1[2] =4
>>> list1       
[1, 'a', 4, True]
>>> list2
[1, 'a', 1.1, True]
>>> list2[2] =7 
>>> list1       
[1, 'a', 4, True]
>>> list2       
[1, 'a', 7, True]

元组

tuple 元组相当与只能赋值一次的列表，元组初次赋值后无法进行增删改查等操作

元组的创建

#  元组的第一创建 以小括号标识，每个元素用逗号分隔,小括号也可以省略不写
tuple0 = (1,'a',1.1,True)

元组的读取方法与列表都一样.

列表和元组之间可以相互转换，转换为列表函数为：list,列表转换为元组函数为：tuple

# 列表转换为元组
>>> list0 = [1,'a',1.1,True]
>>> tuple0 = tuple(list0) 
>>> tuple0
(1, 'a', 1.1, True)
>>> type(tuple) 
<class 'type'>
>>> type(tuple0) 
<class 'tuple'>

# 元组转换为列表
>>> tuple1 = 2,'b',2.2,False
>>> list1 = list(tuple1)  
>>> list1
[2, 'b', 2.2, False]
>>> type(list1)
<class 'list'>

字典

dict 字典是由若干个键（key）值(value)对(关键字和值) 组成的数组。字典中关键字无法修改，值可以修改。

字典的创建

字典用大括号标识，键与值为一个元素，用冒号分隔，每个元素之间用逗号分隔

>>> dict0={"name":"zhang",'age':32,'zone':'nc'}
>>> dict0
{'name': 'zhang', 'ang': 32, 'zone': 'nc'}
>>> type(dict0) 
<class 'dict'>

字典的读取

# 读取关键字变量名加方括号，方括号内写对应的关键字
>>> dict0['name']
'zhang'
# 以上方法当关键字不存在时，会抛出异常，使用get方法时当关键字不存在时，返回空
>>> dict0.get('name') 
'zhang'
>>> dict0.get('nam') 		#关键字不存在返回空
>>>

字典的修改插入

# 修改指定位置的值
>>> dict0['age'] = 23                           
>>> dict0
{'name': 'zhang', 'age': 23, 'zone': 'nc'}
# 当关键字不存在时，会自动增加一个键值对
>>> dict0['age1'] = 27
>>> dict0
{'name': 'zhang', 'age': 23, 'zone': 'nc', 'age1': 27}
# 一次更新多个元素或增加多个元素
>>> dict0.update({'name':'wang','age1':18,'age2':28}) 
>>> dict0
{'name': 'wang', 'age': 32, 'zone': 'nc', 'age1': 18, 'age2': 28}

字典的删除

# 删除字典的指定元素
>>> del(dict0['age1']) 
>>> dict0
{'name': 'zhang', 'age': 23, 'zone': 'nc'}
# 清空字典,字典变量还在，但内部元素为空
>>> dict0.clear()     
>>> dict0
{}
# 删除字典变量,在访问时会提示变量不存在
>>> del(dict0) 
>>> dict0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dict0' is not defined

字典常用函数

常用函数有 dict.keys 返回字典所有关键字、dict.values 返回字典所有值、dict.items()返回所有关键字和值

# 返回所有关键子
>>> dict0.keys()       
dict_keys(['name', 'age', 'zone', 'age1', 'age2'])
>>> type(dict0.keys())
<class 'dict_keys'>
# 返回所有值
>>> dict0.values()     
dict_values(['wang', 32, 'nc', 18, 28])
>>> type(dict0.values())
<class 'dict_values'>
# 返回所有键值对
>>> dict0.items()        
dict_items([('name', 'wang'), ('age', 32), ('zone', 'nc'), ('age1', 18), ('age2', 28)])
>>> type(dict0.items())
<class 'dict_items'>

程序结构

库

python有自己的标准库和第三方库。

标准库一般存放在python安装目录下的 Lib 目录下

第三方库一般在Lib/site-packages/

程序第一部分首相要导入相关模块:

# 关键字  模块名     as   起别名
import module_name as alias_name

或是值导入模块的某个函数或变量

#从	 模块        导入    函数
from module_name import function_name

从包中导入模块

# 导入  包   下的  模块
import package.module_name

命令块

接下来的部分就是编写命令来实行

流程控制

python程序控制其运行方式大致分三种：顺序结构、条件结构、循环结构

顺序结构

顺序结构为最简单的，命令自上而下顺序运行

print("我是命令1。")
print("我是命令2。")
print("我是命令3。")

结果：

我是命令1。
我是命令2。
我是命令3。

进程已结束,退出代码0

条件结构

条件结构根据条件判断，不同的结果，去执行不同的分支命令，

a = 1
b = 2
if a > b:
	print("a 大于 b")
else:
	print("b 大于 a")

结果：

b 大于 a

进程已结束,退出代码0

循环结构

条件结构根据条件判断，不同的结果，看是否需要继续执行循环命令，

while 循环

a = 1
while a < 10:
    print(a)
    a += 1
pass

结果：

1
2
3
4
5
6
7
8
9

进程已结束,退出代码0

for循环

for i in (1, 2, 3, 4, 5, 6, 7, 8, 9):
    print(i)

结果

1
2
3
4
5
6
7
8
9

进程已结束,退出代码0

函数、类、包

根据命令实现功能分类，又可以把一些命令分装成函数，类，包

函数

我们可以把实现一个更能的代码段组织成一个函数，方便以后使用，不用去写重复实现该功能的代码。

python 有很多内置函数，比如我们使用的print()、int()、str()、bool() 等都是内置函数.

自定义函数

我们也可以写自己需要的功能函数，这种函数叫做自定义函数：用关键字 def 定义。

# 定义函数
def sum_int(x, y):
    return x + y

#调用函数
print(sum_int(3,4))

结果：

7

进程已结束,退出代码0

函数传参

定义函数需要两个参数: x 和 y 。

参数又有形参和实参的说法，定义函数预留的的这两个参数接口就叫做形参。

在调用函数时我们填入的两个参数：3 和 4 就叫做实参。

我们给函数传递参数有多种方式：顺序传参、关键字传参，默认值传参。

def sum_int(x=1,y=1):
    print(x + y)

# 调用函数
 # 顺序传参
sum_int(3,4)
 # 关键字传参
sum_int(x=3,y=4)
 # 默认传参 使用定义函数时给x,y 赋的值
sum_int()

异常处理

sum_int('a',4)

结果

Traceback (most recent call last):
  File "F:\PYTHON\pythontext\procedure.py", line 38, in <module>
    sum_int('a', 4)
  File "F:\PYTHON\pythontext\procedure.py", line 31, in sum_int
    print(x + y)
TypeError: can only concatenate str (not "int") to str

进程已结束,退出代码1

程序运行出错时，python会抛出异常停止程序，我们可以使用 try:except: 处理，保证程序不会终止。

try:
	sum_int('a', 4)
except Exception as e:
	print("出现异常：", str(e))
print("结束")

结果

出现异常： can only concatenate str (not "int") to str
结束

进程已结束,退出代码0

这样程序就正常结束了。

类

类(class) 时各种变量，函数，方法的集合，组成的一个对象，类内还可以对变量，函数方法设置访问权限。

类使用关键字class定义

class abc():
    ········

包

库包含：包、模块，包包含：模块，模块就是一个py文件。

包就是一些一个文件夹，文件件下必须包含__init__.py文件，还有一些相关功能的模块。

trw777

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录