python入门

基本概念和基本数据类型

变量：变量是编程语言中最基本的概念，和字面意思一样，指的就是他们的值可变，和我们 以前学习的方程类似，变量可以代入任何值。

​ 我的理解：变量就是一个可变的量，在变量中可以存任何值

​ 例子：我们把会变的菜价，变成变量，同样也是可以的

变量的命名规则：

​ 变量一般使用： 英文字母、下划线 和 数字组成(变量不能以数字开头和一些特殊符号 如：$、@)
​ 关键字不能做变量名，内置函数最好也不要做变量名

关键字

#如何查看关键字和内置函数
import keyword  #keyword模块记录了python中所有的关键字
print（keyword.kwlist）#keyword.kwlist查到python所有关键字
dir(__builtins__)	#dir(__builtins__)可以查找到python中所有的内置函数

变量的引用：

#如：在同一时间给变量赋值两次
price = 4.50
price = 6.00

输入和输出

输入用：input() 输出用：print()

in_a = input('请输入一个值：')
print('输出的值：',in_a)

注意：input()函数输入的值都是字符串的类型

数值类型

数字类型分为：

​ int 整数：3

​ float 浮点型：3.14

​ bool 布尔型：False True

​ 注意：在python中布尔值的首字母要大写

数值类型的计算

‘+’ 加法运算 例子： …

‘-’ 减法运算 例子: …

‘*’ 乘法运算 例子: …

‘******’ 幂运算 例子：2 ** 3

‘/’ 除法运算 例子：9/6 这个会得到小数：1.5

‘//’ 整除运算 例子：9/6 这个会得到整数：1

‘%’ 取余运算 例子：9/6 这个会得到余数：3

布尔型的加减运算 True+False 所以这里是 1+0

这里我们把True看作1，False看作0

字符串

字符串的定义

定义方式有三种分别为单引号和双引号和三引号

三引号和单引号和双引号有所不同，三引号定义时可以换行

例子：

str1 = 'hello python'
str2 = "hello python"
str3 = '''hello python
你好，python语言'''

字符串的加乘法（不能进行其他运算）

'hello'+'python'
#结果为：'hellopython' 将两个字符串拼接到一起'hello' * 3
#结果为：'hellohellohello' 将3个字符串拼接到一起

字符串的拼接

格式化拼接

s = 'nice to'
t = 'meet you'
r = '!'
#如果我们想在每个字符串之间加空格或者其他字符，我们可以在%s之间加
print('%s %s %s' %(s,t,r))

利用join拼接

#如果我们想在每个字符串之间加空格或者其他字符，我们可以在''里面加
print('*'.join([s,t,r]))

利用format拼接

#如果我们想在每个字符串之间加空格或者其他字符，我们可以在{}之间加
print('{}*{}{}'.format(s,t,r))

字符串格式化

%r：原样输出对象

常用的数值模块

浮点高精度计算

#1.01-0.9 值为：0.10999999999999999
import decimal #导入浮点高精度模块
decimal.Decimal('1.01') - decimal.Decimal('0.9')
#值为:Decimal('0.11')

使用时注意传入的是字符串

数学模块(math)

import math
math.pi

Math模块有常见的数学函数，有需要的可以在这个模块里面找找

dir(math)	#查找所有的数学函数
'''
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
'''

条件语句

if语句

if的使用：if后面跟上表达式，注意加冒号和缩进

else使用：else不能单独使用，后面直接跟上冒号和缩进，没有判断

elif使用：只能跟在if后面，不能单独使用

if常用运算符

‘>’ ‘>=’ ‘<’ ‘<=’ ‘==’ ‘!=’

#语法：
if(表达式):   #if代表'如果'的意思 如果表达式成立，执行if下的代码块代码块
#else代表'否则'的意思 如果if的表达式不成立我们就可以输出else下的代码块
else:		 代码块

'''
例子：如果周末不下雨，就去逛街，否则就在家学习像这样的一个选择，该如何用代码表示出来呢？
'''
weather = input('请输入一个天气：')
if weather == 'sun':print('逛街')
else:print('在家')

优化的原则： 1. 逻辑更加简单，比如少用否定，多用肯定

​ 2.用英文代替拼音，减少歧义

多重选择

三目运算符

#语法： 代码块	判断表达式	代码块
print('ok') if a>0 else print('no')

注意：只有简单if判断可以使用，过于复杂判断就不要使用了，那样会影响代码的可读性

逻辑运算符

逻辑运算符中返回的值都是bool型 False、True

and为"与运算"

#逻辑与运算符 用and
if x>1 and y>9:print('两个表达式为真')
else:print('两个表达式其中一个为假或两个都为假')

or为“或运算”

#逻辑或运算符 用or
if x>1 and y>9:print('两个表达式其中一个为真')
else:print('两个表达式都为假')

False为”非运算“

if False: #可在False加一个not，就输出第一句print('为真就为假')
else:print('为假就为真')

逻辑短路

逻辑运算过程中，如果已经能够得到最后的值，则不会再进行后面的判断，

这个称为逻辑短路

a = 3
a >6 and a> 2 #这里判断a>6为False时，后面就不会继续判断，造成逻辑短路a>1 or a>2	#

while循环

while 的使用和 if 类似，
判断为真的时候则运行缩进里面的代码，
判断式为假时则停止循环

#例：打印1到10以内吧的数
i = 1
while i<10:print(i)i+=1

使用 while 循环要注意：
循环一定能够停止
注意判断式是否能够为假

while 循环，只要条件为True，就会一直执行while下的代码块，知道while判断为False才会停止运行

#语法：
while 表达式:#只要表达式为True，while下的代码块会一直执行，直至while为False循环体/代码块

while循环中else的使用

#语法：
while 表达式:循环体
else:	#当while中的表达式为False时执行代码块

#break和continue的使用

#break
i = 1
while i<10:print(i)if i==5:break #结束该循环i+=1
'''
while 后面也可以直接跟上True，但是内部就必须要使用break来终止循环使用break终止的循环，是不会执行else的内容
'''

#continue
i = 1
while i<10:if i==5:continue #结束本轮循环，进入下一轮循环print(i)i+=1

迭代循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。

遍历一个字符串

之前学过字符串

#for的遍历一个字符串
str = "python"
for i in str: #遍历str这个字符串print(i,end = ',')

end 可以设置每个值打印之后输出的字符串，默认是换行

range()函数**

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

range()函数两个参数

#语法：range(开始值，结束值)
for x in range(10):print(x)

注意：range(10) 不是 0 到 10 的值，而是值 0 到 9。

range() 函数默认 0 为起始值，不过可以通过添加参数来指定起始值：range(3, 10)，这意味着值为 3 到 10（但不包括 10）：

for x in range(3,10):print(x)

range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)：

使用 3 递增序列（默认值为 1）：

for x in range(2,30,3):print(x)

continue

for i in range(1,100):if i%2 == 0 or i%3 == 0:continue	#结束本次循环，进入下一次循环elif i%17 == 0:break		#结束循环else:print(i,end = '')
else:		#前面有break所以这句不会执行print('循环结束')

for 循环中的 else 关键字指定循环结束时要执行的代码块：

else:循环结束时执行else，但是如果之前有break就不会执行else

#打印1到9所有数字，并在循环结束时打印一条消息：
for i in range(10):print(i)
else:print('代码块结束！')

嵌套循环

嵌套循环是循环内的循环。

“外循环”每迭代一次，“内循环”将执行一次：

#九九乘法表
for i in range(1,10):for j in range(i,10):print(f'{i}*{j}={i*j}',end = ' ')print(end = '\n')

pass语句

for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误。

for x in [0, 1, 2]:pass

序列类型-列表、元祖

列表的定义

列表就如同一个菜篮子，可以放菜，也可以放钱
因此列表里面既可以放字符串，也可以放数值类型数据

除此之外，列表里面可以几乎放python的任何对象

#列表里面既可以放字符串，也可以放数值类型数据
thislist = ['python','java','php',100]

列表的增删改查

index:可以根据元素找到元素的索引

添加：append、extend、insert 这三个方法

如果是直接两个列表相加，记得重新赋值，否则不会改变值

删除：pop、remove、clear 这三个方法

删除是不可逆的，所以删除前要确定好

copy: 复制列表，类似于保存快照

count： 可以统计列表里面某个元素出现的次数，也属于查找

reverse：是将列表顺序颠倒过来，没有排序

sort：对列表中元素进行排序，采用Timsort算法排序

#列表里面既可以放字符串，也可以放数值类型数据
thislist = ['python','java','php',100]
#列表的索引取值，也可以是负数
thislist.index(1)
thislist.index(-1) #这里是从列表的最后面开始取值#添加元素
thislist.append('香蕉')	#在列表中添加一个元素
thislist.extend(['肉','豆腐'])	#在列表中添加多个个元素
thislist.insert(1,'水')	#在列表列表指定位置添加元素
print(thislist)
'''
注意：如果是两个列表相加，记得重新赋值，不然列表的值不会改变
'''#列表的切片
#列表还可以根据一个范围来取值，这称为切片
'''
注意：切片是两个范围之间取值，且后面的数取不到切片时范围超过也没有关系切片时还可以指定步长切片中[起始值:结束值:步长]
'''
thislist[0:1]
thislist[0:100]
thislist[0:4:2]#删除元素
thislist.pop()#默认删除最后一个元素
thislist.pop(1)#删除指定位置元素
thislist.remove('php')#删除指定元素
thislist.clear()#清空所以元素#修改元素
#利用索引取值可以替换
thislist[2] = 'C#'#复制列表 copy()
thislist2 = thislist.copy()#统计某个元素在列表中出现的次数 count()
i = thislist.count()#颠倒列表顺序，没有排序
thislist.reverse()#对列表进行升序和降序
thislist.sort()	#sort()里面不加参数默认为升序，也可以在sort()里面加 reverse = True
thislist.sort(reverse = False)

元组

元组：类似于列表，也可以用索引取值，但是元素不能进行修改，一旦定义无法修改

如果元组只有一个元素，还是要跟上逗号‘，’，否则会当作一个元素，而不是元组

拆包：元组可以同时赋值给多个变量，只要变量个数不超过元组长度，变量前面加上 号则可以将多于元素都接受，并组成一个列表*

#定义一个元组
tuple_a =('this','is','tuple',2,5,8)
a,b,*c = tuple_a

列表和元组的相互转换

tuple()#将列表转换为元组
list() #将元组转换为列表

字符串方法

把首字母转换为大写使用 capitalize() 方法

str1 = 'hello'
str2 = str.capitalize()

把字符串转换为小写 casefold() 方法

str2 = str3.casefold()

count() 方法返回指定值在字符串中出现的次数。 ]

语法

#value：要检索的字符串	start：开始检索的位置默认为0 end:结束检索的位置。默认是字符串的结尾。
string.count(value, start, end)

#返回值 "apple" 在字符串中出现的次数：
txt = "I love apples, apple are my favorite fruit"
x = txt.count("apple")
print(x)

encode() 方法使用指定的编码对字符串进行编码。如果未指定编码，则将使用 UTF-8。

语法

#encoding:你要使用的编码	errors：规定错误方法
string.encode(encoding=encoding, errors=errors)

endswith() 方法使用如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。

语法:

#value:必需。检查字符串是否以之结尾的值。
#start:可选。整数。规定从哪个位置开始检索。
#end:可选。整数。规定从哪个位置结束检索。
string.endswith(value, start, end)

str = 'hello world!'
str.endswith('!')

find方法的定义和使用

find() 方法查找指定值的首次出现。

如果找不到该值，则 find() 方法返回 -1。

find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常

#语法：string.find(value, start, end)
str = 'hello world!'
str2 = str.find('w')
print(str2)

isalnum方法

如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。

txt = "Company12"
x = txt.isalnum()
print(x)	#True

isalpha() 方法

如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。

txt = "Company12"
x = txt.isalnum()
print(x)  #False

isdecimal()方法

如果字符串中的所有字符都是小数，则返回 True。

isdigit()方法

如果字符串中的所有字符都是数字，则返回 True。

isdentifiter()方法

如果字符串是标识符，则返回 True。

islower()方法

果字符串中的所有字符都是小写，则返回 True。

isupper()方法

果字符串中的所有字符都是大写，则返回 True。

ismumberi()方法

如果字符串中的所有字符都是数，则返回 True。

isprintabe()方法

如果字符串中的所有字符都是可打印的，则返回 True。

ispace()方法

如果字符串中的所有字符都是空白字符，则返回 True。

istile()方法

如果字符串遵循标题规则，则返回 True。

swapcase()方法

切换大小写，小写成为大写，反之亦然。

title()

把每个单词的首字符大写

upper()

把每个单词的首字符小写

zfill()

在字符串的开头填充指定数量的 0 值。

字符转义字符

# \n指换行
str = '''this
is
python! '''str #结果：'this\nis\npython! '

# \t指水平制表符，一个\t 代表4个空格
str = 'this\tis\tpython'
print(str) # 结果：this	is	python

# \\ 转义反斜杠
str1 = 'this\\python'
print(str1) # 结果：this\python

# \\ 转义单斜杠
str2 = 'this\'s python'
print(str2) # 结果：this's python

## \\ 转义空字符
# r 取消转义 str = r'this\0python'
encode(encoding = 'UTF8') # encoding 声明编码格式 #encode 编码
bd.decode('UTF8') #decode解码

注意：如果字符串中含有转义字符，我们可以在字符串外加r，取消转义

散列类型-字典、集合

字典是一个无序，可变和有索引的集合，字典也用花括号编写，拥有键值

字典的定义

dict_a = {}#定义一个空字典
dict_b = dict(a=1,b=2)	#dict()函数定义一个字典
#常规的定义方式
thisdict = {"name":"sherrin","age":18,"sex":"nan"
}

可以通过引用键名来访问字典；

也可以使用**get()**方法一样也是通过键名获得键值

a = thisdict["age"]
b = thisdict.get("age")

更改一个键值

引用键名来更改特定的值

thisdict = {"name":"sherrin","age":18,"sex":"nan"
}
thisdict["age"] = 21

遍历字典

for遍历字典的键和值

for i in thisdict:print(i)	#遍历键

for i in thisdict:print(thisdsict[i])	#遍历值

使用**values()**返回字典的值

for i in thisdict.values():print(i)

使用**items()**函数返回字典的键和值

for i,j in thisdict.items():print(i,j)

in关键字检查字典中指定键是否存在

if "age" in thisdict:print(yes)

字典长度

使用len()方法

print(len(thisdsict))

添加项目

通过使用新的索引键并为其赋值，就可以添加到字典中

thisdict["class"] = "软件1905"

删除项目

使用pop()方法删除指定键名的项

thisdict.pop("class")

**popitem()**删除最后插入的项 （在 3.7 之前的版本中，删除随机项目）

print(thisdict.popitem())

del 关键字也具有指定键名删除项目

del thisdict["class"]

del 也可以完全删除字典，但会报错

del thisdictprint(thisdict) #this 会导致错误，因为 "thisdict" 不再存在。

**clear()**清空关键字

thisdict.clear()

**copy()**方法来复制字典

mydict = thisdicr.copy()

**dict()**方法创建副本

mydict = dict(thisdict)

嵌套字典

myfamily = {"child1":{"name":"张三","age":21},"child2":{"name":"李四","age":18}
}

集合

集合是一个无序的和无索引，在python中集合用花括号表示

创建集合

#常规的定义方法
thisset = {"apple", "banana", "cherry"}
#使用set函数定义一个集合
thisset = set(("apple", "banana", "cherry")) # 请留意这个双括号

注释：集合是无序的，因此你无法确定项目的显示顺序

集合的运算

集合的交集(&)：指的是两个集合中相同的元素

一个空集合用：set() 表示

集合的并集(|)：指的是两个集合不相同的元素合并在一起

集合的差集(-)：指的是两个集合减去两个集合中相同的元素

in关键字

我们可以通过in关键字来确定一个内容是否在集合中

例：

thisset = {"apple", "banana", "cherry"}
print('apple' in thisset)

更改项目

集合一旦创建就无法更改项目，但可以添加项目

添加项目

要将一个项添加到集合，请使用 add() 方法。

要向集合中添加多个项目，请使用 update() 方法。

例：

使用 add() 方法向 set 添加项目：

thisset = {"apple", "banana", "cherry"}
thisset.add('sherrin')

使用 update() 方法将多个项添加到集合中：

thisset = {"apple", "banana", "cherry"}
thisset.update('sherrin','邪灵'，'dog')

获取Set的长度

使用**len()**方法

例：

thisset = {"apple", "banana", "cherry"}
print(len(thisset))

删除项目

要删除集合中的项目，请使用 remove() 或 discard() 方法。

thisset = {"apple", "banana", "cherry"}
thisset.remove("banana")
print(thisset)

**注释：**如果要删除的项目不存在，则 remove() 将引发错误。

使用**discard()**来删除

thisset = {"apple", "banana", "cherry"}
thisset.discard("banana")

**注释：**如果要删除的项目不存在，则 discard() 不会引发错误。

我们还可以使用**pop()**方法来删除,但此方法默认删除最后一项，**pop()**方法返回值是删除的项目

例：

thisset = {"apple", "banana", "cherry"}x = thisset.pop()print(x)	#输出删除的项目print(thisset)	#输出集合

**注释：**集合是无序的，因此在使用 pop() 方法时，您不会知道删除的是哪个项目。

**clear()**方法清空集合

thisset.clear()

del 彻底删除

#语法：
del thisset

集合的判断

isdisjoint() 判断一个集合是否有交集 有交集返回False，没有交集返回True

issubset() 判断一个集合是否被包含于另一个集合，包含返回True

issuperset() 判断是否包含于，不包含返回False

合并两个集合

使用union()和update()

union() 方法返回一个新集合，其中包含两个集合中的所有项目：

update() 方法将 set3中的项目插入 set4 中：

set3 = {'a','b'}
set4 = {'a','b','c','d'}
set3 .union(set4)
set3.update(set4)
print(set3)

**注释：**union() 和 update() 都将排除任何重复项。

python基础提升

函数的基本概念

函数的定义

# def 函数名(): #必备参数	默认参数	不定长参数（元祖、字典不定长）
# 例：
def fun():print('这是一个函数fun()')fun()	#调用这个函数

函数的返回值 return

#return为一个结束函数 ，return结束之后的语句将不会在执行
#return	会返回一个值
def fun():print('这是一个函数fun()')return 5	#这个rerun把函数结束了，所以下边语句不会执行print("上边rerurn执行后，这个语句就不会执行")	#去掉上边return语句，就可以输出该语句
#调用这个函数
print(fun())
#没有添加return语句，不会返回一个值，输出函数fun()会输出一个None

函数参数、作用域

函数的参数

Python中函数主要有这三种参数：
必备参数、默认参数 和 不定长参数

其中不定长参数有：元组和字典两种类型

def fun(x,y=10,*t,**d):		#*代表元组		**代表字典print(x)print(y)print(t)print(d)
tu = (1,2,3,4)
di = {"name":"sherrin","age":21}
fun(10,20,*tu,**di)	#注意：这里调用的时候需要加上*号

必备参数： 调用时必须传入
默认参数： 调用可以不传入，不传入时默认使用默认值
不定长参数： 可以传入也可以不传入，不传入时默认为空元组和空字典
字典传入是，必须是键值对的形式，且只能最后传入，定义时也只能放在最后面

函数作用域

全局变量和局部变量

全局变量:函数外面的变量成为全局变量

局部变量：函数里面的变量成为局部变量

global

如果想要在函数内部改变外面不可变对象变量的值，则需要在函数内部使用 global 关键字

global 是全局变量声明，声明之后可以在全局使用，这里的全局指的是当前py文件中

注意：函数内外名字要一致，否则就是一个新变量

a = 100
def fun():global a #在这使用了global，函数外部变量/(全局变量)可以再函数内部改变a+=1print(a)

nonlocal

如果是嵌套的函数，则不能使用global，需要使用nonlocal 关键字

def fun():a = 100def funa():nonlocal a	#在这使用了nonlocal,在函数的嵌套中，内部变量可以修改内部变量	/a+=1print(a)

递归函数 函数自己调自己

递归函数简单来说就是函数内部调用自己，和while循环类似，也需要一个结束条件，否则超出递归深度就会报错

def fun(num):if	num<=1:return 1else:return num + fun(num-1)	#5+4+3+2+1
fun(5)

匿名函数（ lambda ）

匿名函数就是没有函数名的函数，主要用来定义那种不是特别复杂的函数，常用用于函数的参数中

lambda可以任意一个参数，但只能有一个表达式

sum = lambda a : a+10	# a为参数	a+10为表达式
sum(2)

文件的基本操作

open()函数

open()函数里面两个参数：文件名和模式名,还可以设置编码格式 encoding(‘UTF8’)

​ 文件的四种打开方式：

# "r" - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错。
# "a" - 追加 - 打开供追加的文件，如果不存在则创建该文件。
# "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件。
# "x" - 创建 - 创建指定的文件，如果文件存在则返回错误。

文件的读取

f = open('1.txt','r')
print(f.read()) #读取全部
print(f.readline())	#读取单条
print(f.readlines())  #读取多条

文件的写入

f = open('1.txt','w')
print(f.write('hello,python')) #write()写入一条字符串，但会覆盖上一条字符串,我们可以用a来写入字符串

文件的追加

f = open('1.txt','a')
print(f.write('hello,python')) #这里我们就不会覆盖上一条字符串，在其后追加一条字符串

文件的创建

f = open('2.txt','x')	#创建一个指定的文件

文件的保存(flush)和关闭(close)

flush():文件最开始写入会写入到内存中，只有调用flush刷新到硬盘中才能保存到文件

close():关闭文件也会自动保存修改到文件中

绝对路径

#通过绝对路径读到文本里的内容，当然也可以写
f = open("r'D:\python\C.txt'","r",encoding = 'UTF8')
print(f.read())

with :with可以自动关闭文件

with open('D:python/test/test.txt','w+') as f:#我这里的路径是绝对路径f.write('this is file')f.flush()

文件流

#文件流'''
在内存中打开一个文件流，如同打开一个文件
文件流有getvalue方法可以获取内容
'''
import io
string_io = io.StringIO()
string_io.write('this is file')
string_io.getvalue()

文件的目录操作

还有一下方法：
makedirs 创建多层目录
remove 删除文件
rmdir 删除目录
Removedirs 删除多层目录
system 调用系统命令
walk 遍历文件夹

相对路径

​ 我们还可以创建不在同级目录下的文件

​ 上一级目录：…/

​ 同一级目录：./

​ 下一级目录：/

#使用相对路径
f = open(r'../ceshi/a.txt',"w",encoding = 'UTF8')	#创建了一个a.txt文件
f = open(r'./ceshi/a.txt',"w",encoding = 'UTF8')
f = open(r'ceshi/a.txt',"w",encoding = 'UTF8')	#这里注意下，要想到下一级目录需先创建下一级目录
f.write('小事儿')	#为a.txt写入字符串

模块和包

导入模块的语法

使用import导入模块，主要有两种用法：

• import 模块名1[as 别名1]，模块名2[as 别名2]，… : 导入整个模块
• from 模块名 import 成员名1[as 别名1]， 成员名2[as 别名2]，…，：导入模块中指定成员

上面两种import语句的区别主要有两点：

• 第一种import语句导入模块内的所有成员（包括变量、函数、类等）；第二种import语句只导入模块内的指定成员（除非使用 from 模块名 import *）
• 当使用第一种import语句导入模块中的成员时，必须添加模块名或模块别名作为前缀；当使用第二种import语句导入模块中的成员时，无须使用任何前缀，直接使用成员名或成员别名即可da

import导入模块介绍

#python中模块指的是一个py文件
#导入sys整个模块
import sys
#使用sys模块名作为前缀来访问模块中的成员
sys.path()

为模块指定别名

#导入sys整个模块,并指定别名为 s
import sys as s
#这里取别名后，就必须使用别名作为前缀，如果仍旧使用模块名，则会报错：
s.path
#使用模块名做前缀报错：
'''
Traceback (most recent call last):File "", line 1, in sys.path
NameError: name 'sys' is not defined
'''

一次导入多个模块，多个模块之间用逗号隔开

# 导入sys、os两个模块
import sys,os
# 使用模块名作为前缀来访问模块中的成员
print(sys.argv[0])
# os模块的sep变量代表平台上的路径分隔符
print(os.sep)

为多个模块指定别名

# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
import sys as s,os as o
# 使用模块别名作为前缀来访问模块中的成员
print(s.argv[0])
print(o.sep)

使用from … import 导入模块内指定成员的用法介绍

# 导入sys模块的argv成员
from sys import argv
# 使用导入成员的语法，直接使用成员名访问，不能添加前缀
print(argv[0])

如果为成员名添加模块名前缀，则会报错

# 导入sys模块的argv成员
from sys import argv
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])print("--------------------")# 如果为成员名添加模块名前缀，则会报错
print(sys.argv[0])

为成员名指定别名

# 导入sys模块的argv成员，并为其指定别名v
from sys import argv as v
# 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
print(v[0])# 如果指定了别名，就必须使用别名，若仍使用成员名，则会报错
print(argv[0])

导入模块中的多个成员

# 导入sys模块的argv,winver成员
from sys import argv, winver
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])
print(winver)

导入模块中的多个成员,并指定别名

# 导入sys模块的argv,winver成员，并为其指定别名v、wv
from sys import argv as v, winver as wv
# 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
print(v[0])
print(wv)	#这里输出的使我们安装的python的版本号

定义一个模块

'''
这是我们编写的第一个模块，该模块包含以下内容：
my_book：字符串变量
say_hi：简单的函数
User：代表用户的类
'''
print('这是module 1')
my_book = '疯狂Python讲义'
def say_hi(user):print('%s,您好，欢迎学习Python' % user)
class User:def __init__(self, name):self.name = namedef walk(self):print('%s正在慢慢地走路' % self.name)def __repr__(self):return 'User[name=%s]' % self.name# ===以下部分是测试代码===
def test_my_book ():print(my_book)
def test_say_hi():say_hi('孙悟空')say_hi(User('Charlie'))
def test_User():u = User('白骨精')u.walk()print(u)
# 当__name__为'__main__'（直接使用python运行该模块）时执行如下代码
if __name__ == '__main__':test_my_book()test_say_hi()test_User()

模块中的__ all __变量

在默认情况下，如果使用“from 模块名 import *”这样的语句来导入模块，程序会导入该模块中所有不以下画线开头的程序单元，这是很容易想到的结果。
有时候模块中虽然包含很多成员，但并不希望每个成员都被暴露出来供外界使用，此时可借助于模块的__all__变量，将变量的值设置成一个列表，只有该列表中的程序单元才会被暴露出来。
定义一个包含__all__变量的模块（all_module.py）

'测试__all__变量的模块'def hello():print("Hello, Python")
def world():print("Pyhton World is funny")
def test():print('--test--')# 定义__all__变量，指定默认只导入hello和world两个程序单元
__all__ = ['hello', 'world']

示范模块中__all__变量的用处

# 导入all_module模块内所有成员
from all_module import *
hello()
world()
test() # 会提示找不到test()函数输出结果：
Hello, Python
Pyhton World is funny
Traceback (most recent call last):File "C:\Users\zz\.spyder-py3\temp.py", line 5, in <module>test() # 会提示找不到test()函数NameError: name 'test' is not defined

上面程序显示，只导入了__all__变量所列的程序单元，函数test()默认没有被导入。

__all__变量的意义在于为模块定义了一个开放的公共接口。通常来说，只有__all__变量列出的程序单元，才是希望该模块被外界使用的程序单元。因此，为模块设置__all__变量还是比较有用的。比如一个实际的大模块可能包含了大量其他程序不需要使用的变量、函数和类，那么通过__all__变量即可把它们自动过滤掉，这还是非常酷的。 ****

如果确实希望程序使用模块内__all__列表之外的程序单元，有两种解决方法:

• 第一种是使用“import 模块名”来导入模块。在通过这种方式导入模块之后，总可以通过模块名前缀（如果为模块指定了别名，则使用模块的别名作为前缀）来调用模块内的成员。
• 第二种是使用＂from 模块名 import 程序单元”来导入指定程序单元。在这种方式下，即使想导入的程序单元没有位于all列表中，也依然可以导入。

os和sys

os与sys模块的官方解释如下：
os: This module provides a portable way of using operating system dependent functionality.
这个模块提供了一种方便的使用操作系统函数的方法。
sys: This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter.
这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。
os 常用方法
os.remove() 删除文件
os.rename() 重命名文件
os.walk() 生成目录树下的所有文件名
os.chdir() 改变目录
os.mkdir/makedirs 创建目录/多层目录
os.rmdir/removedirs 删除目录/多层目录
os.listdir() 列出指定目录的文件
os.getcwd() 取得当前工作目录
os.chmod() 改变目录权限
os.path.basename() 去掉目录路径，返回文件名
os.path.dirname() 去掉文件名，返回目录路径
os.path.join() 将分离的各部分组合成一个路径名
os.path.split() 返回( dirname(), basename())元组
os.path.splitext() 返回 (filename, extension) 元组
os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间
os.path.getsize() 返回文件大小
os.path.exists() 是否存在
os.path.isabs() 是否为绝对路径
os.path.isdir() 是否为目录
os.path.isfile() 是否为文件
sys 常用方法
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.modules.keys() 返回所有已经导入的模块列表
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdin 标准输入
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本
总结：
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

什么是包？

包就是一个文件夹，包里面可以可以包含多个模块

#比如：我们创建一个fk_package的文件夹指定为一个包

我们可以在包下创建多个模块

python基础高级

面向对象的基本概念

类的定义和使用

p 称为Person类的实例，这里语境的意思是具体的某个人

self是实例自己

__init__是初始化函数，在实例化时会自动的调用

实例通过点（ . ）操作符来调用属性或方法

'''
语法：class 类名(首字母大写):变量		属性名函数		方法
'''
class Person: #def __init__(self,name,age): #__init__ 是初始化函数，在实例化时会自动的调用this.name = namethis.age = agedef play(self):	 #self是实例自己 play()☞是一个方法print('%s正在玩游戏' % self.name)
p = Person('sherrin',21) #实例化一个对象
p.name			#调用属性名
p.play()		#掉用play()这个方法

类的析构函数

在类中增加__del__函数，当删除实例的时候，就会调用此方法

del 关键字用来删除对象

def __del__(self):print('%s事情做完了'% self.name)
p = Person('sherrin',21)
del p	#删除p这个对象

类的定义、继承、多继承

class Person: #创建一个类Person

class Person:   #创建一个类Persondef __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sexdef play(self): #一个play()方法print(f'{self.name}正在旅游')
class Dad(Person):def play(self):print(f'{self.name}在上班')super().play()	#重写了父类Person的play()方法class Mon(Person):def play(self):print(f'{self.name}在家')super().play()	#重写了父类Person的play()方法class Son(Dad,Mon):def play(self):print(f'{self.name}在玩游戏')super().play()  #重写了父类Dad和Mon的play()方法

测试

#交互模式下
s = Son('sherrin',21,'nan')
s.play()
'''
在Son没有重写父类的方法时
输出：》》	sherrin正在玩游戏在Son重写父类的方法时
输出：》》	sherrin正在玩游戏sherrin在上班
在这里注意一下，Son同时继承了Dad,Mon，这里遵循就近原则，直调了Dad方法
'''

面向对象高级提升

内置函数

创建一个类

class Person:def __init__(self,name,age):self.name = nameself.age = agep = Person('sherrin',22)

hasattr(对象，属性值) 判断属性是否存在

hasattr(p，'name')
#存在返回一个True
#不存在返回一个False

setattr() 判断属性是否存在，有责增，无责改

setattr(p,'sex','nan')

getattr() 获取属性值，无责报错

getattr(p,'name')

delattr() 删除属性

delattr(p,'sex')

注意：属性名需要加引号

对象关系方法

class Person:def __init__(self,name,age):self.name = nameself.age = agep = Person('sherrin',22)class Dad(Person):def fun():super().__init__()

issubclass() 判断一个类是否另外一个类的子类

issubclass(Dad，Person)

isinstance() 判断实例对象是不是类的实例对象

isinstance(p,Person)	#返回一个 True
isinstance(p,Dad)	#返回一个 False

魔法方法、协议

魔术方法概念：

​ Python中很多内置方法都是两个下划线在两边，中间是单词名字，并且这样的方法名字有一定的特殊的含义，把这种方法都称之为魔法方法

比如这里的__new__方法，就是最开始调用的一个方法，会在初始化之前自动调用

class Person:def __init__(self):print('这是实例化的时候自动被调用')#重写def __new__(cls):print('这是一个实例化方法，会在init之前调用')return super().__new__(cls)

利用__new__方法，可以很方便的去实现一个类的单例模式

单例模式的意思是：类始终只有一个实例存在，不会同时出现多个实例

class Person:def __init__(self):print('这是实例化的时候自动被调用')#重写def __new__(cls):print('这是一个实例化方法，会在init之前调用')#判断类中是否存在这个_istance属性if not hasattr(cls,'_istance'):cls._istance = super().__new__(cls)  return cls._istance

输出的魔术方法

def __repr__(self):return '这是你的实例方法'
def __str__(self):return 'this is you实例方法'

协议

序列协议

协议是由两个或两个以上的魔术方法

'''
__len__查询类里面的对象长度
__getitem__通过下标获取对象下标的值
'''class Person:def __init__(self,*args):   #这里*号的意思代表把传进来的参数装进元组里面#拿到元素self.value = argsdef __len__(self):#查询对象长度return len(self.value)#下标取值def __getitem__(self,key):return self.value[key]

迭代协议

只要类实现了__iter__ 和 next 方法，则这个类就是迭代器，

因此只要实现这两个方法，则是可以迭代对象

'''
迭代协议
__iter__ 把一个对象转换文一个可 迭代对象
__next__ 定义一个步长更新
'''class frange:def __init__(self,end = 10):self.start = -1self.end = end#签订一个迭代器的协议def __iter__(self):return self#定义步长更新def __next__(self):self.start += 1if self.start>=self.end:#主动报错raise StopIterationelse:return self.start

上下文协议

同样的还有上下文协议，即我们之前讲过的with的使用，

只要类里面定义__enter__和__exit__这两个方法，则可以使用with去使用此对象

'''
上下文协议
__enter__程序开始之前调用
__exit__程序结束时调用
'''
import time
class Num:#获取当前时间def __enter__(self):self.start = time.time()return self.startdef __exit__(self,exc_type,exc_val,exc_tb):self.end = time.time()print('程序执行的时间为：',self.end-self.start)
with Num():#放需要执行的程序for i in range(1000000):pass

装饰器和迭代器

​ yield ：返回一个生成器， 暂停函数

def fun():print(2)yieldprint(5)
f = fun()#返回生成器对象
next(f)#迭代处理

装饰器

装饰器：回调+闭包
闭包：外层函数返回内层函数的函数体
回调：把一个函数作为参数传递给另一个函数

#回调
def fun():print('我是fun函数的结果')def funa(f): #必备参数f()  #函数体print('我是func函数的结果')#我们将fun()函数体当作参数funa(fun)

闭包

#闭包
def fun():def func():print('内层函数的执行结果')return func
#将fun()函数赋给a
a = fun()
#这里的a()函数就是fun()函数
a()

这就是一个装饰器

def fun(f):def func():f()print('内层函数的执行结果')return func@fun
def mao():print('这是一个mao函数')

内置装饰器

class Person:def __init__(self,name,age):self.name = nameself.age = age@property   #调用的属性的形式来调用方法def play(self):print('小十二不会玩')@classmethod    #得到类本身def study(cls):print(cls)@staticmethod   #不需要自动传递selfdef statics():print('================')

异常

程序出错时的异常

try:print(name)#NameError表示未定义变量
except NameError:print('未定义变量')

文件不存在

except FileNotFoundError:print('文件不存在')

#捕获最终错误 as 别名

except Exception as e:print(i)else:print('没有异常就会执行else里面')finally:print('不管代码有没有错误，都会执行到这里')

注意事项：

1. try 后面必须跟上 except

2. except 只有在函数中才能使用 return

3. finally 不管是否发生异常，始终都会执行

4. raise 可以主动抛出异常

#assert 断言 跟if语句相似，如果判断为True,正常执行，如果为False,抛出错误
#assert一般用于测试

正则基本概念

元字符、re模块

正则表达式（re）

元字符：具有特殊含义的字符元素(只能代表一个字符)
. 通配符：可以用来表示任意一个字符、，但不包含\n，匹配符合要求的数据，并全部拿到 findall(规则，数据)：根据规则从数据中选择

例子：

import re  #导入正则模块
str = 'shehrrin123_*+\n, @'
res = re.findall('.',str)  #. 不包含\n
print(res)

转义符
\b 被用于表示词语的边界， 不匹配任何实际字符，所以是看不到的 它只在字符集合内表示空格 \B取反
\d 匹配数字
\w 匹配 字母、数字、下划线、汉子等字符
\s 匹配 空白、空格、制表符、换行符

例子：

import re  #导入正则模块
str = 'this is python'
#'\bis'代表is左边有空格就输出is 
#'is\b'代表is右边有空格就输出is 
#'\bis\b'代表is两边有空格就输出is
res = re.findall(r'is\b',str) 
print(res)

托字符 限制开头 ^
美元符 限制结尾 $

‘*’ 匹配0次或者多次

import re  #导入正则模块
str = '151734\t82321\t'
res1 = re.findall(r'^1',str) 
res2 = re.findall(r'\t$',str) 
res3 = re.findall(r'\t*',str) 

匹配次数 {}

import re  #导入正则模块
str = '151734\t82321\t'
res1 = re.findall(r'\d{2}',str) #\d{2}对数字每次匹配2个
res1 = re.findall(r'\d{2,4}',str) #\d{2,4}每次匹配2个或4个

贪婪和非贪婪匹配
贪婪：尽可能匹配更多 .*
非贪婪：尽可能匹配最少 .*?

import re  #导入正则模块
str = 'this is python
这是一个python
'
res1 = re.findall(r'<.*>',str) 
res1 = re.findall(r'<.*?>',str) 

字符 集合 []
注意：字符集合中的脱字符代表取反

import re
str = '12342fghhjjh*+ \t'
res = re.findall(r'[^0-9]',str)  #字符集合中的脱字符代表取反
res = re.findall(r'^[0-9]',str)  #限制开头

分组匹配 () 只保留小括号里面的内容
(?:)括号前面的也保留
(?=)保留前面的
(?!)表示匹配到的不保存

import re  #导入正则模块
str = 'this is python
这是一个python
'
res1 = re.findall(r'(python)',str) #() 只保留小括号里面的内容
res2 = re.findall(r'(?:is)',str) #(?:)括号前面的也保留
res3 = re.findall(r'(?=python)',str) #(?=)保留前面的
res4 = re.findall(r'(?!this is python)',str) # (?!)表示匹配到的不保存

正则模块方法

compile() 提前编译规则
sub() 替换字符串方法
split(‘正则规则’,数据)字符串的分割

str = '12,32442 fdfg de\t*%@'
r = re.compile('\d') #提前编译规则
res1 = r.findall(str)
res2 = r.sub('12','hello',str) #替换字符串方法
res3 = r.split(' |,',str) #用空格或逗号来分割字符串

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！