python系统学习2

作者: 奶油裙子 | 来源:发表于2023-03-18 16:02 被阅读0次

python学习笔记目录
Mac下python2与python3共存问题
Mac多版本Python共存
python 学习笔记
python编程 | 第一章起步（环境搭建）
mac下利用pyenv管理多个版本的python
Python-day-01
一行代码轻松极速安装lxml，拿走不谢！
【软件安装】---Ubuntu系统下安装python3
Python 3基础

1、成员检测与标识号检测

使用"in"和"not in"运算符来判断某个对象是否为序列的成员
in：判断对象是否在序列（列表/字符串/元组/字典）中，如果是则返回True
not in:判断对象是否不在序列中，如果是则返回True

print("4" in "1234")  #字符串4是否存在于字符串“1234”当中
print(1 in (1,2,3,4))
print(1 in [1,2,3,4])
print("名字" in {"名字":"柚子"})  #判断的是键

运行结果：
True
True
True
True

print(3 not in (1,2,4,5))

运行结果：
True

2.判断某两个对象是否相同

判断某两个对象是否相同，则是用is 和not is 运算符
is(是）判断对象是否相同
is not(不是) 判断对象是否不同
数字/字符串/元组都是不可变数据类型表面一样完全一样
列表/字典/集合都是可变的数据类型表面一样其实不是同一个对象

a = "柚子"
b = "111"
print(a is not b)
c = "111"
d = "111"
print(c is d)
h = (1,2,3)
m = (1,2,3)
print(h is m)

运行结果：
True
True
True

f = [1]
g = [1]
print(f is g)
aa = {"名字":"柚子"}
bb = {"名字":"柚子"}
print(aa is bb)
zz = {1,2,3}
xx = {1,2,3}
print(zz is xx)

运行结果：
False
False
False

3.python的条件语句：

if...elif...else...分支语句
if语句是可以单独存在的
if elif(无数个) else
if else

if 2>6:
    print("你好")
elif 4>6:
    print("柚子")
elif 5>6:
    print("小明")
else:
    print("以上条件均不满足")

运行结果：以上条件均不满足

a = int(input("请输入你的成绩："))
if a>=85:
    print("优秀学生")
elif a>=75:
    print("优良学生")
elif a>=60:
    print("一般学生")
else:
    print("成绩不合格")

运行结果：
请输入你的成绩：86
优秀学生

4.python数据类型转换

（1）检测数据类型的方法type()

a = "123"
b = 123
print(type(a))
print(type(b))

运行结果：
<class 'str'>
<class 'int'>
（2）强制类型转换
<1>str():可以把其他类型数据转化为字符串类型
注意：所有类型都可以转化为字符串类型

a = 123
res_a = str(a)
print(res_a,type(res_a))
c = True
res_c = str(c)
print(res_c,type(res_c))

运行结果：
123 <class 'str'>
True <class 'str'>

print(str([1,2,3]))  #可以直接转化，程序中是"[1,2,3]"

运行结果：
[1, 2, 3]
<2>int():可以把其他数据类型转化为整型
<3>float():可以把其他类型数据转化为浮点型
注意：
数字类型之间可以相互转换
只有字符串可以转换为数字类型
并且字符串中的元素必须为纯数字，否则无法转换
字符串当中“-123”可以被处理，其他位置不可以

#整型转换为浮点型
a = 123
print(type(a))
r_a = float(a)
print(r_a,type(r_a))
#浮点型转换为整型
b = 3.64
r_b = int(b)  #不遵守四舍五入
print(r_b)
#布尔值也是数字 转换为整型
c = True
r_c = int(c)
print(r_c)

运行结果：
<class 'int'>
123.0 <class 'float'>
3
1
<4>bool():可以把其他类型转换为True或False
a.容器类型转布尔类型
容器类型数据：字符串，列表，元组，字典，集合
非容器类型数据：数字类型，布尔类型
容器中为空：False
容器中有元素：True
b.数字类型转布尔类型
int类型中，0为False，其他为真
float类型中，0.0为False，其他为真

a = ""  #空字符串
b = []  #空列表
c = ()  #空元组
d = {}  #空字典
e = set()  #空集合
print(bool(a), bool(b), bool(c), bool(d), bool(e))
bb = [123, 11]
print(bool(bb))

运行结果：
False False False False False
True

aa = 0
print(bool(aa))
bb = 0.0
print(bool(bb))
cc = 123
print(bool(cc))

运行结果：
False
False
True
<5>list()
a.数字类型是非容器类型，不能转换为列表

a = 123
print(list(a))

运行结果：
TypeError: 'int' object is not iterable
b.字符串转列表时，会把字符串中的每一个字符当作列表的元素

b = '123456abcd'
print(list(b))

运行结果：
c.元组转列表时，会把元组中的每一个元素当作列表的元素

c = (1,2,3,"abcd")
print(list(c))

运行结果：
[1, 2, 3, 'abcd']
d.字典转列表时，会保留字典中的键

d = {
    "名字":"xiaoming",
    "年龄":18,
    0:1
}
print(list(d))

运行结果：
['名字', '年龄', 0]
e.集合转列表时，结果是无序的，因为集合本身就是无序的

e = {1,2,3,4,6,5}
print(set(e))

运行结果：
{1, 2, 3, 4, 5, 6}
<6>tuple():其他类型数据转元组类型与其他数据类型转列表类型的规则相同
a.数字类型是非容器类型，不能转换为为元组
b.字符串转化为列表时，会把字符串中的每一个字符当作元组的元素
c.列表转元组时，会把列表中的每一个元素当作元组的元素
d.字典转元组时，只保留字典中的键
e.集合转元组时，结果都是无序的，因为集合本身就是无序的

a = "abcd"
print(tuple(a))

运行结果：
('a', 'b', 'c', 'd')
<7>set():其他数据转换为集合类型
a.数据类型是非容器类型，不能转换为集合
b.字符串转集合时，结果是无序的
c.列表转集合时，结果是无序的
d.元组转集合时，结果是无序的
e.字典转集合时，只保留字典中的键，结果是无序的
<8>dict():其他转字典类型
a.数字类型是非容器类型，不能转换为字典
b.字符串不能转字典类型，因为字符串不能生成二级容器
c.列表类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2

a = [[1,2],["a","b"],["名字","youzi"]]
print(dict(a))

运行结果：{1: 2, 'a': 'b', '名字': 'youzi'}
d.元组类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2

b = ((1,2),(3,4))
print(dict(b))

运行结果：{1: 2, 3: 4}
e.集合不能转字典类型

5.isinstance()函数

isinstance()用来判断一个对象是否是一个已知的类型
isinstance()函数的返回值是布尔型，
若对象的类型是已知的类型，那么就返回True，否则返回False
语法如下：
isinstance(对象，对象类型)
int(整数) float(浮点数) bool(布尔值) str(字符串)
list(列表) tuple(元组) set(集合) dict(字典)

a = 123
print(isinstance(a, int))
print(isinstance(a,(int, float)))

运行结果：
True
True

6.for循环

（1）for循环用来遍历序列
通过不使用下标的方式来实现对序列中每一个元素的访问
列表/元组/字符串/字典/集合

for i in [1,2,3]:
    print(i)

运行结果：
1
2
3

for i in {"名字":"柚子","年龄":18}:
    print(i)

运行结果：
名字
年龄

for i in range(0,10): #0-10之间，0123456789
    print(i)

运行结果：
0
1
2
3
4
5
6
7
8
9
遍历数字 range()
（2）遍历字典的键和值
遍历字典的键

d = {
    "名字":"柚子",
    "年龄":18
}
for a in d:
    print(a)

运行结果：
名字
年龄
遍历字典的键和值

for a in d.items():
    print(a)

运行结果：
('名字', '柚子')
('年龄', 18)
（3）range函数
<1>range(0,4) 0123 取左不取右
<2>range(0,6,2) [0,6) 步长为2

for i in range(0,6,2):
    print(i)

运行结果：
0
2
4
（4）双层for循环 if判断

a = [1,2,3,[10,20,30],[50,60,70]]
for i in a:
    #判断，满足条件，是否是列表
    if isinstance(i, list):
    # 提取工作，提取列表中的数据
        for x in i:
            print(x)

运行结果：
10
20
30
50
60
70

7.while循环

c = 0
while c<6:
    print(c)
    c+=1  #自我增加 c = c+1
else:
    print("c变量的值已经为6，不满足c<6的条件了")

运行结果：
0
1
2
3
4
5
c变量的值已经为6，不满足c<6的条件了

8.循环中的关键字

（1）break 语句可以跳出for和while的循环体

for i in "python":
    print(i)
    break

运行结果：p

for i in "python":
    if i =="t":
        break
    print("当前的字符是",i)

运行结果：
当前的字符是 p
当前的字符是 y
（2）continue 语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环

for i in "python":
    continue
    print(i)

运行结果：（空，直接跳出来了）

a = 0
while a<6:
    print("我爱你")
    a += 1
    continue
    print("我喜欢你")

运行结果：
我爱你
我爱你
我爱你
我爱你
我爱你
我爱你

9.pass语句

pass是空语句，是为了保持程序结构的完整性
它用于那些语法上必须要有什么语句，但程序什么也不做的场合(占位)

for i in range(0,10):
    pass

10.函数的定义和调用

创建函数的目的是封装业务逻辑，实现代码的重用。
（在之前的章节中，针对各类对象调用了非常多的函数，这些都是python 的内建函数。这些函数的功能都是预先设计好的，但在实际生产过程中，使用最多的还是自定义函数)
（1）创建函数的关键字：def

#创建函数，用到"def关键字 空格 函数名字():",和变量定义规则一样的
#1.创建函数
def abc():
    print("我爱你")
#2.运行函数
abc()

运行结果：我爱你

#定义一个做加法运算的函数
def abc(a,b):
    print(a+b)
abc(100,200)

运行结果:300

11.函数的参数位置

python函数的参数具有灵活性，其定义的方法可以接受各种形式的参数，也可以简化函数调用方法的代码
（1）函数中的pass关键字
保持代码结构的完整性

for i in range(0,5):
    pass

（2）位置参数
在对函数进行调用的时候，有几个位置参数就需要传递几个参数，否则会触发异常。并且，传入参数与函数参数列表是一一对应。传入的参数可以是任何数据类型。
注意：函数，先定义函数，再调用

def abc(a,b):
    print(a+b)
abc(33,66)

运行结果：99
（3）默认参数
默认参数是指有默认值的参数，在对该函数进行调用的时候，可以不必显示传递给该函数。当不传递值的时候，函数将使用默认值。

def abc(a=300,b=400):
    print(a+b)
abc()  #省略传入所有参数，函数会使用默认参数的默认值
abc(600)  #为第一个默认参数传入值，另一个默认参数继续使用默认值
abc(600,300)  #为两个默认参数都传入值
abc(b=1000)  #指定一个默认参数进行传值

运行结果：
700
1000
900
1300
注意：默认值只能会执行一次，这条规则在默认值为可变对象（列表、字典以及大多数类的实例）时非常重要
官方建议默认参数尽量使用不可变对象
因为可变对象会存储在后续调用中传递给它的参数

def abc(a,b=[]):  #列表是可变列表
    b.append(a)
    print(b)
abc(100)
abc(200)  #期望的是[200],但是我们得到的是[100,200]

运行结果：
[100]
[100, 200]

def abc(a,b=None):
    if b is None:
        b = []
    b.append(a)
    print(b)
abc(100)
abc(200)

运行结果：
[100]
[200]
（4）关键字参数
函数调用时，指定参数名称，成为关键字参数（别和默认参数混淆，这里是参数调用）
注意：函数调用时，关键字参数必须在普通参数的后面

def abc(x, a=100, b=200):  #默认参数，函数定义的时候传参
    print(a+b)
abc(100, a=200, b=600)  #关键字参数，函数调用的时候

（5）限定关键字的形参（命名关键字参数）
特点：必须使用关键字方式传递参数
限定关键字形参，当然就是为了限制后面几个参数只能按关键字传递，这往往是因为后面几个形参名具有十分明显的含义，显式写出有利于可读性；或者后面几个型参随着版本更迭很可能发生变化，强制关键字形式有利于保证跨版本兼容性

def abc(a,b=100,c=200): #默认参数后面必须也是默认参数
    print(a)
    print(b)
    print(c)
abc(100,c=600,b=700)  #参数的位置可以调整

def abc(a,*,c,d): 
    print(a)
    print(c)
    print(d)
abc(100,c=600,b=700) #c,d必须使用关键字传参

（6）可变参数
<1>*参数：最常见的变量名是args,看到该变量名，一眼就知道变量args指向一个tuple（元组）对象
自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象

def abc(a,*args):
    print(a)
    print(args)
abc(100)

运行结果：
100
()

def abc(a,*args):
    print(a)
    print(args)
abc(200,300,400,500)

运行结果：
200
(300, 400, 500)
<2>**参数：最常见的变量名是kwargs,看到该变量名，一眼就知道变量kwargs指向一个dict对象
自动收集所有未匹配的关键字参数到一个dict对象中，变量名kwargs指向了此dict（字典）对象

def abc(a,**kwargs):
    print(a)
    print(kwargs)  #b指向的是空字典{} 键值对
abc(100,x=200,y=300)

运行结果：
100
{'x': 200, 'y': 300}
（7）参数的解包（拆包）
参数数据类型是：字符串/列表/元组/集合/字典的时候可以解包
传递实参时，可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递

s = "123"
l = [4,5,6]
t = (7,8,9)
s1 = {1,2,3}
def abc(a,b,c):
    print(a)
    print(b)
    print(c)
abc(*s)
abc(*l)
abc(*t)
abc(*s1)

运行结果：
1
2
3
4
5
6
7
8
9
1
2
3
只拆字典的键：

d = {
    "名字":"yozui",
    "年龄":"18",
    "技能":"python"
}
def abc(a,b,c):
    print(a)
    print(b)
    print(c)
abc(*d)  #只拆键

运行结果：
名字
年龄
技能
只拆字典的值：（键必须要与自定义函数的参数一致）

d = {
    "名字":"yozui",
    "年龄":"18",
    "技能":"python"
}
def abc(名字,年龄,技能):
    print(名字)
    print(年龄)
    print(技能)
abc(**d)

运行结果：
yozui
18
python
（8）参数解包和可变参数一起使用
注意：**参数只收集未匹配的关键字参数

def abc(a,*args):
    print(a)
    print(args)
abc(100,(100,200,300))
abc(100,*(100,200,300))

运行结果：
100
((100, 200, 300),)
100
(100, 200, 300)

d = {
    "名字":"yozui",
    "年龄":"18",
    "技能":"python"
}
def abc(a,**kwargs):
    print(a)
    print(kwargs)
abc(100,**d)

运行结果：
100
{'名字': 'yozui', '年龄': '18', '技能': 'python'}
（9）函数中各种参数排列位置的注意事项
<1>可变参数，必须定义在普通参数以及默认参数的后面
<2>函数定义时，二者同时存在，一定需要将args放在*kwargs之前

def abc(a,name="youzi",*args,**kwargs):
    print(a)
    print(name)
    print(args)
    for i in args:
        print(i)
    print(kwargs)
    for key,value in kwargs.items():
        print(key)
        print(value)
abc(100,"zhangsan",1,2,3,4,x=100,y=200,c=300)

运行结果：
100
zhangsan
(1, 2, 3, 4)
1
2
3
4
{'x': 100, 'y': 200, 'c': 300}
x
100
y
200
c
300

12.函数的返回值

（1）python中的函数可以使用return返回数据，也可以不用return返回，则默认返回"None"
return关键字，用来函数执行的时候，帮助我们返回我们处理好的结果

def abc(a,b,c):
    return a+100,b+200,c+300
r = abc(100,200,300)
print(r)
x,y,z = r  #元组的解包
print(x)
print(y)
print(z)

运行结果：
(200, 400, 600)
200
400
600
（2）函数的返回函数
<1>函数里面嵌套函数
<2>函数返回函数

def abc():
    def xyz():
        return [1,2,3]
    return xyz
r = abc()
r2 = r()
print(r2)

运行结果：
[1, 2, 3]

python学习笔记目录
Python学习笔记目录(倒序） Python学习-异常 Python学习-面向对象 Python学习-文件系统 ...
Mac下python2与python3共存问题
python从入门到放弃； mac os系统里面自带了python2，当我们需要学习python3的时候就要自己安...
Mac多版本Python共存
最近了解学习一下python的语法，想了解最新python 3.x版本，发现系统默认的是2.x版本的，而且系统默认...
python 学习笔记
参考《Python web接口开发与测试》这本书学习 1，python2 与python3在一个系统内可以同时存在...
python编程 | 第一章起步（环境搭建）
python编程系统学习指路：快速学习 | python编程：从入门到实践 | Windows 1. python...
mac下利用pyenv管理多个版本的python
前言经常遇到这样的情况：系统自带的Python是2.x，自己需要Python 3.x；某些机器学习的框架（如...
Python-day-01
一、Python课程介绍 1、十个阶段：基础学习（4周） web前端学习（2周） linux系统学习（1周）数...
一行代码轻松极速安装lxml，拿走不谢！
Win系统同时安装python2 python3 python2下安装lxml py -2 -m pip inst...
【软件安装】---Ubuntu系统下安装python3
前言：Ubuntu系统默认安装了python2，但是python3也可以和python2在一个系统中共存。 1.安...
Python 3基础
Python优点：学习成本低、免费、开源、适用广一、计算机的组成 1、软件系统和硬件系统组成 2、重点：CPU（...