python语法学习

最新推荐文章于 2024-07-27 12:20:46 发布

da..

最新推荐文章于 2024-07-27 12:20:46 发布

阅读量544

点赞数 4

分类专栏： # python 文章标签： python

本文链接：https://blog.csdn.net/weixin_45840087/article/details/120987171

版权

python 专栏收录该内容

5 篇文章 3 订阅

订阅专栏

文章目录

第一章初了解
- 1. print函数
- 2.转移字符
第二章基本知识
- 1.二进制与字符编码
- 2.python的保留字和标识符
- 3.变量的定义和使用
- 4.数据类型
- 5.注释
第三章常用运算符
- 0.本章总结
- 1.input
- 2.运算符
第四章结构咯
- 1.顺序结构
- 2.对象的布尔值：
- 3.Python的选择结构—— if 语句
第五章转圈圈
- 0.本章总结
- 1.range（）函数
- 2.while循环
- 3.for-in循环
- 4.break、continue与else语句
- 5.嵌套循环
第六章一次排开
- 0.本章总结
- 1.列表的创建与删除
- 2.列表的查询操作
- 3.列表元素的增、删、改操作
- 4.列表元素的排序
- 5.列表推导式
第七章夫妻站
- 0.本章总结
- 1. 什么是字典
- 2.字典的原理
- 3.字典的创建与删除
- 4.字典的查询操作
- 5.字典元素的增、删、改操作
- 6.字典推导式
第八章是排还是散
- 0.本章总结
- 1.什么是元组
- 2.元组的创建方式
- 3.元组的遍历
- 4.什么是集合
- 5.集合的创建
- 6.集合的增、删、改、查操作
- 7.集合生成式
sp:列表、字典、元组、集合总结
第九章一串连一串
- 0.本章总结
- 1.字符串驻留机制
- 2.字符串的常用操作
- 3.字符串的比较
- 4.字符串的切片比较
- 5.格式化字符串
- 6.字符串的编码转换
第十章水晶球不调用不动
- 0.本章总结
- 1.函数的创建和调用
- 2.函数的参数传递
- 3.函数的返回值
- 4.函数的参数定义
- 5.变量的作用域
- 6.递归函数
第十一章全民来找茬
- 0.本章总结
- 1.bug的由来及分类
- 2.不同异常类型的处理方式
- 3.异常处理机制
- 4.pycharm的调式模式
第十二章找对象不积极思想有问题
- 0.本章总结
- 1.两大编程思想
- 2.类和对象的创建
- 3.类对象与类属性
- 4.类方法与静态方法
第十三章接着找对象
- 0.本章总结
- 1.封装
- 2.继承
- 3.方法重写(理解不了)
- 4.object类
- 5.多态
- 6.特殊方法和特殊属性
第十四章百宝箱
- 0.本章总结
- 1.什么叫模块
- 2.自定义模块
- 3.以主程序的形式执行
- 4.python中的包
- 5.第三方模块的安装以及使用
第十五章大宝藏
- 0.本章小结
- 1.编码格式介绍
- 2.文件的读写原理
- 3.文件的读写操作
- 4.文件对象常用的方法
- 5.with语句（上下文管理器）
- 6.目录操作

本文章只是对学习内容的总结，是作者对下面视频学习的笔记。
本文不适合当参考资料学习。个人建议以看下面视频为主+动手操练+最后看本文
对应部分（内容只是视频上讲解内容的复刻，再次强调本文只是记笔记而已）
附上视频链接：
B站python语法入门学习

第一章初了解

1. print函数

#用print输出数字
print(520)
print(98.5)
#输出字符串
print('helloworld')#引号告诉计算机不需要你理解，你照着输出就可以了
#输出表达式
print(3+1)
#将数据输出到文件中，注意1.所指定的盘符存在，2.使用file*fp
fp=open('D:/text.txt','a+')
#a+如果文件不存在就创建，存在就在文件内容的后面继续追加
print('helloworld',file=fp)#相当于print >> fp, "helloworld"
fp.close()
#不进行换行输出（输出内容在一行当中）
print('hello','world','python')#有一些疑问

关于讲解print函数的好文章
 关于内容用print输出到文件的解答

2.转移字符

print('hello\nworld') #\ +转义功能的首字母 n-->newline的首字母表示换行
print('hello\tworld')
print('helloooo\tworld')#\t：四个空格一个制表位，如果前面制表位没满就不需要重开制表位，如果满了，重开制表位
print('hello\rworld')#\r:同行回车，会覆盖之前数据
print('hello\bworld')#\b退一个格，将o退没了

print('http:\\\\www.baidu.com')#\\：就表示\
print('婆娑世界是多姿多彩的空间\'器宇里有不宣的欲望\'')#\'相当于',同理\"相当于“
#原字符：不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r 或者R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠，可以双斜杠没问题
#print(r'hello\nworld\')
print(r'hello\nworld\\')

请点击-关于转义字符的详细介绍引用文章一
 请点击-关于转义字符的详细介绍引用文章二

第二章基本知识

1.二进制与字符编码

print(chr(0b100111001011000))#chr后面学
print(ord('乘'))#不用管ord是什么，后面学

二进制没啥好说的，都是基础。字符编码附上ASCALL码表
在这里插入图片描述
字符编码的发展，了解就好咯。

2.python的保留字和标识符

# 变量啊，函数名啊，给想要的对象命名叫做标识符，
# 但是有些特殊标识符符不能使用，因为系统已经使用，
# 故这部分一般称为保留字。

3.变量的定义和使用

在这里插入图片描述

name='萨菲娜'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
name='阿兰'
print(name)

4.数据类型

在这里插入图片描述

#整数类型：正数，负数，0
n1=90
n2=-76
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n2,type(n2))
#整数可以表示二进制，八进制，十六进制
print('十进制',118)
print('二进制',0b10101111)#二进制以0b开头
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1EAF)#十六进制以0x开头

在这里插入图片描述

#浮点型
a=3.14159
print(a,type(a))
n1=1.1
n2=2.2
print(n1*n2)#输出是会出现很多0，这没办法
from decimal import Decimal#浮点数的相加，想取得整洁一点，用decimal,先学会用就行
print(Decimal('1.1')+Decimal('2.2'))

在这里插入图片描述

#布尔型可以转化成整数计算
print(f1+1) #2 1+1的结果为2 True表示1
print(f2+1) #1 0+1的结果为1，False表示0

在这里插入图片描述

#字符串类型
str1='思念观世音'
str2="看的远些  再远一些"
str3='''留恋的少些
    再少一些'''
str4="""请施我身心无畏的力量 
观世音观世音菩萨 """
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

在这里插入图片描述

name='da.'
age=23
print(type(name),type(age))
print('''你是否和我一样疑惑？''')
print('-------------str()：将其他类型转换成str类型------')
a=10
b=198.8
c=False
print(type(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))
print('----------int()：将其他的类型转int类型-----------')
s1='128'
f1=98.7
s2='76.77'
ff=True
s3='hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1)))
print(int(f1),type(int(f1)))
#print(int(s2),type(int(s2)))#将str转换成int类型，报错，因为字符串是小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #将str转换为int类型，字符串必须为数字串，非数字串（字符串其表示整数可以，字符串表示含小数不可以）是不可以转换的
#float转换
print('-------float()函数，将其他数据类型转成float类型')
s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(type(s1),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
#print(float(s3),type(float(s3)))#文字类无法转成整数

5.注释

在这里插入图片描述

#coding: gbk
#输入功能
print('hello')
'''我是 
 我是多行注释'''

第三章常用运算符

0.本章总结

在这里插入图片描述

1.input

在这里插入图片描述

present=input('大圣想要什么礼物？:')
 print(present,type(present))

a=int(input('请输入一个数：'))
b=int(input('请输入一个数：'))
print(type(a),type(b))
print(a+b)

2.运算符

在这里插入图片描述

print(1+1)
print(1-1)
print(2*4)
print(1/2)#除法
print(11/2)#除法
print(11//2)#整除运算
print(11%2)#取余
print(2**2)#**表示幂运算 2次方

在这里插入图片描述

print(1+1)
print(1-1)
print(2*4)
print(1/2)#除法
print(11/2)#除法
print(11//2)#整除运算
print(11%2)#取余
print(2**2)#**表示幂运算 2次方

print(-9//-4)
print(-9/4) #一正一负的公式向下取整咯(这一版本好像不取整)
print(9/-4)#
print(9%-4)#-3 公式 余数=被除数-除数*商  9-（-4）*（-3） 9-12-->-3
print(-9%4)#3
```![在这里插入图片描述](https://img-blog.csdnimg.cn/4890981f157c42e6b0a25fe5de4f7b6a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZGEuLg==,size_20,color_FFFFFF,t_70,g_se,x_16)

```python
i=3+4
print(i)
a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))

在这里插入图片描述
你的链式赋值实际上只有一个存储单元，却有三个用了三个变量指向这个存储单元。

i=3+4
print(i)
a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('------支持参数赋值-------')
a=20
a+=30
print(a)
a-=10 #相当于
print(a)

a//=2
print(a,type(a))
a/=3
print(a)
print('---------支持解包----------')
a,b,c=20,30,40
print(a,b,c)
print('----交换两个变量的数值-----')
a,b=10,20                  
print('交换之前',a,b)          
a,b=b,a                    
print('交换之后',a,b)

在这里插入图片描述

a,b=10,20               
print('a>b么？',a>b)      
print('a<b?',a<b)       
print('a<=b么？',a<=b)    
print('a>=b吗',a>=b)     
print('a==b吗',a==b)     
print('a!=b吗',a!=b)     
'''一个 = 称为赋值运算符，==称为比较运算
一个变量由三部分组成，标识，类型，值      
比较的是数值还是标识呢？比较的是数值      
比较对象的标识是使用 is   '''     
a=10                    
b=10                    
print(a==b)             
print(a is b)           
#说明a与b的id相等             
#以下代码没学过，后面会给大家讲解       
lst1=[11,22,33,44]      
lst2=[11,22,33,44]      
print(lst1==lst2)       
print(lst1 is lst2)     
print(id(lst1))         
print(id(lst2))

在这里插入图片描述
位运算二进制内部运算过程讲解

print(4|8)   
print(4&8)   
print(4<<1)  
print(4<<2)

在这里插入图片描述

第四章结构咯

1.顺序结构

代码是自上到下一句一句执行的。

2.对象的布尔值：

在这里插入图片描述

3.Python的选择结构—— if 语句

Python 中的选择结构就是判断真假。
Python 中的 if 语句就是选取要执行的结果，从一些备选的操作中进行要选择的语句。
if 语句后面跟着一个或多个可选的 elif （“ else if ”），以及一个最终可选的 else 。在 if 语句执行时，Python 会执行第一个计算结果的代码块，如果之前的都是假时，就执行 else 块。
if 语句的三种表达形式：

1、单分支
#单分支，如果条件正确就执行一个单向 if 语句。当且仅当条件为 true 时，一个单向 if 语句执行一个动作。注：if 块中的语句都要在 if 语句之后缩进。
if 1:
	print("今天是星期一")
2、双分支
#双向 if - else 语句根据条件是真还是假来决定要执行哪一个动作。如果条件是 True ，那么 if 语句执行第一个动作，但当条件是 False 使用双向 if-else 来执行第二个动作。
success = input("请输入您的成绩：")
success = int(success)
if success >= 60:
	print("及格")
else:
	print("不及格")
3、多分支
#3.1 输入1~7数字，表示今天星期几：
res = input("请输入1~7数字，表示今天星期几:")
if res == "1":
	print("今天星期一")
elif res == "2":
	print("今天星期二")
elif res == "3":
	print("今天星期三")
elif res == "4":
	print("今天星期四")
elif res == "5":
	print("今天星期五")
elif res == "6":
	print("今天星期六")
elif res == "7":
	print("今天星期天")
else:
	print("您输入了错误的数字")
4.pass语句
if res==1:
	pass
else
	pass

第五章转圈圈

0.本章总结

在这里插入图片描述

1.range（）函数

在这里插入图片描述

#range的三种创建方式
'''第一种创建方式，只有一个参数（小括号中只给了一个数值）'''
r=range(10)
print(r)#range(0, 10)
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第二种创建方式，给出了两个参数（小括号中给了两个数）'''
r=range(1,10)
print(list(r))#[1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第三种创建方式，给了三个参数（小括号中给了三个数）'''
r=range(1,10,2)
print(list(r))#[1, 3, 5, 7, 9]

'''判断指定的整数，在序列中是否存在 in,not in'''
print(10 in r)#False
print(9 in r)#True
print(10 not in r)#True
print(9 not in r)#False

2.while循环

在这里插入图片描述

'''
4步循环法
1.初始化变量
2.条件判断
3.条件执行体（循环体）
4.改变变量
总结：初始化变量与条件判断的变量与改变变量为同一个
'''
'''初始化变量为0'''
a=0
sum=0
'''条件判断'''

while a<5:
    '''条件执行体'''
    sum+=a
    '''改变变量'''
    a+=1
print('和为',sum)
#看一个例子
'''计算1到100之间的偶数和'''
sum=0
a=1
while a<=100:
    if a%2==0:
        sum+=a
    a+=1
print('1-100之间的偶数和',sum)

3.for-in循环

在这里插入图片描述

#第一次取出来的是p,将p赋值给item,将item的数值输出
for item in 'python':
    print(item)
#range(range产生一个整数序列，--)也可以是一个可迭代对象
for i in range(10):
    print(i)
#如果在循环体中不需要使用到自定义变量，可以将自定义变量写为'_'
for _ in range(5):
    print('留恋的少些，再少一些')
print('使用for循环，计算1和100之间的偶数和')
sum=0
for item in range(1,101):
    if item %2==0:
        sum+=item
print('1到100之间的偶数和：',sum)

4.break、continue与else语句

在这里插入图片描述

'''从键盘录入密码，最多录入3次，如果正确就结束循环'''
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
#用while 循环解决
a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1

在这里插入图片描述

'''要求输出1到50之间所有5的倍数
要求使用的是continue函数
'''
print('------使用continue--------')
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

在这里插入图片描述

#没有碰到break执行else
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码错误')
else:
    print('对不起，三次密码均输入错误')

a=0
while a<3:
    pwd=input('please key the password:')
    if pwd=='8888':
        print('password is correct')
        break
    else:
        print('password is false')
    a+=1
else:
    print('对不起，三次密码输入均是错误')

5.嵌套循环

在这里插入图片描述

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,i*j,end='\t')
    print()

在这里插入图片描述

'''流程控制语句break与continue在二重循环中的使用'''
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            break
        print(j)
'''流程控制语句break与continue在二重循环中的使用'''
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')
    print()

第六章一次排开

0.本章总结

在这里插入图片描述

1.列表的创建与删除

在这里插入图片描述

'''创建列表的第一种方式，使用[]'''
lst=['hello','world',98]
'''创建列表的第二种方式，使用内置函数list()'''
lst2=list(['hello','world',98])

在这里插入图片描述

2.列表的查询操作

在这里插入图片描述

'''创建列表的第一种方式，使用[]'''
lst=['hello','world',98,'hello']
print(lst.index('hello'))#如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
#print(lst.index('Python'))#ValueError
#print(lst.index('hello',1,3))
'''创建列表的第二种方式，使用内置函数list()'''
print(lst.index('hello',1,4))

lst=['hello','world',98,'hello','world',234]
print(lst[2])
print(lst[-3])
print(lst[10])#IndexError list indexout of range

在这里插入图片描述

print('------获取列表多个元素，切片-------')
lst=[10,20,30,40,50,60,70,80]
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段',id(lst2))
print(lst[1:6])
print(lst[1:6:])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[1::2])
print('------step步长是负数的情况--------')
print('原列表：',lst)
print(lst[::-1])
#start=7,stop 省略 step=-1
print(lst[7::-1])

在这里插入图片描述

print('------元素是否在列表中-------')
lst=[10,20,30,40,50,60,70,80]
print(10 in lst)
print(100 not in lst)

print('------列表元素的遍历-------')
for item in lst:
    print(item)

3.列表元素的增、删、改操作

在这里插入图片描述

print('------在列表末尾添加元素-------')
lst=[10,20,30]
print('before',lst,id(lst))
lst.append(100)
print('after',lst,id(lst))
#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)
lst3=[True,False,'hello']
#在任意位置上添加N多个元素
lst[1:]=lst3
print(lst)

在这里插入图片描述

lst=[10,20,30,40,50,60,30]
lst.remove(30)#从列表中一处一个元素，如果有重复只移除第一个元素
print(lst)
#lst.remove(100)#VlaueError:list.remove(x):x not in list
#pop()根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(5) #IndexError :pop index out of range 如果索引位置不存在，将抛出异常
lst.pop()#如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)
print('-------切片操作-删除至少一个元素，将产生一个新的列表对象------')
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)

'''不产生新的列表对象，而是删除原列表中的内容'''
lst[1:3]=[]
print(lst)

'''清楚列表中的所有元素'''
lst.clear()
print(lst)
'''del语句将列表对象删除'''
del lst
print(lst) #name 'lst' is not defined

在这里插入图片描述

lst=[10,20,30,40]
#一次修改一个值
lst[2]=100
print(lst)
lst[1:3]=[300,400,500,600]
print(lst)

4.列表元素的排序

在这里插入图片描述

lst=[20,40,10,98,54]
print('排序前的列表',lst,id(lst))
#开始排序，调用列表的对象的sort方法，升序排序
lst.sort()
print('排序后的列表',lst,id(lst))

#通过指定的关键字参数，将列表的元素进行降序排序
lst.sort(reverse=True)#reverse=True 表示降序排序，reverse-false就是升序排序
print(lst)
lst.sort(reverse=False)
print(lst)

print('---------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-------')
lst=[20,40,10,98,54]
print('原列表',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list)

5.列表推导式

在这里插入图片描述

lst=[i*i for i in range(1,10)]
print(lst)

'''列表中的元素的值2，4，6，8，10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)

第七章夫妻站

0.本章总结

在这里插入图片描述

1. 什么是字典

在这里插入图片描述

2.字典的原理

在这里插入图片描述

3.字典的创建与删除

在这里插入图片描述

'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student)

4.字典的查询操作

在这里插入图片描述

scores={'张三':100,'李四':98,'王五':45}
'''第一种方式，使用[]'''
print(scores['张三'])
#print(scores['陈六']) #KeyError:‘陈六’
'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('陈六'))
print(scores.get('麻七',99))

5.字典元素的增、删、改操作

在这里插入图片描述

scores={'张三':100,'李四':98,'王五':45}
'''key的判断'''
print('张三' in scores)
print('张三' not in scores)
del scores['张三']#删除指定的key-value对
#scores.clear() #清空字典的元素
print(scores)
scores['陈6']=98 #新增元素
print(scores)
scores['陈6']=100#修改元素
print(scores)

在这里插入图片描述

scores={'张三':100,'李四':98,'王五':45}
#获取所有的key
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys))#将所有的key组成的试图转换成列表

#获取所有的value
values=scores.values()
print(values)
print(type(values))
print(list(values))

#获取所有的key=value对
items=scores.items()
print(items)
print(list(items))

在这里插入图片描述

scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

在这里插入图片描述

6.字典推导式

在这里插入图片描述

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
d={item.upper():price for item,price in zip(items,prices)}
print(d)

第八章是排还是散

0.本章总结

在这里插入图片描述

1.什么是元组

在这里插入图片描述

2.元组的创建方式

在这里插入图片描述

'''第一种创建方式，使用（）'''
t=('python','world',98)
print(t)
print(type(t))
t2='python','world',98
print(t2)
print(type(t2))

t3='python',
print(t3)
print(type(t3))
'''第二种创建方式，使用内置函数tuple()'''
tl=tuple(('python','world',98))
print(tl)

'''空元组的创建方式'''
'''空列表的创建方式'''
lst=[]
lst1=list()

d={}
d2=dict()
#空元组
t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

在这里插入图片描述

t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试t[1]修改为100'''
print(id(100))
#t[1]=100 #元组是不允许修改元素的
'''由于[20，30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)#向列表中添加元素
print(t)

3.元组的遍历

在这里插入图片描述

'''元组的遍历'''
t=('python','world',98)
'''第一种获取元组元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #tuple index out of range
'''遍历元组'''
for item in t:
    print(item)

4.什么是集合

在这里插入图片描述

5.集合的创建

在这里插入图片描述

'''第一种创建方式使用{}'''
s={2,3,4,5,6,7,8,9}#集合中的元素不允许重复
print(s)

'''第二种创建方式是使用set()'''

s1=set(range(6))
print(s1,type(s1))

s2=set([1,2,3,4,5,6,7,7])
print(s2,type(s2))

s3=set((1,2,4,4,5,65))#集合中的元素是无序的
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))

s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))

'''定义一个空集合'''
s6={} #dict字典类型
print(type(s6))

s7=set()
print(type(s7))

6.集合的增、删、改、查操作

在这里插入图片描述

#集合的相关性操作
s={10,20,30,40,400,60}
'''集合元素的判断操作'''
print(10 in s)# true
print(100 in s)
print(10 not in s)
print(100 not in s)
'''集合元素的新增操作'''
s.add(80)
print(s)
s.update({200,400,300})#一次至少添加一个元素
print(s)
s.update([100,99,8])
s.update((78.64,56))
print(s)

'''集合元素的删除操作'''
s.remove(100)
print(s)
#s.remove(500) #KeyError: 500
s.discard(500)
s.discard(300)
print(s)
s.pop()
s.pop()
#s.pop(400)#set.pop() takes no arguments (1 given)
print(s)
s.clear()
print(s)

在这里插入图片描述

s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)
print(s!=s2)

'''一个集合是否是另外一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))

'''一个集合是否是另外一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset())

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))
s4={100,200,300}
print(s2.isdisjoint(s4))

在这里插入图片描述

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))
s4={100,200,300}
print(s2.isdisjoint(s4))
'''交集'''
print(s1.intersection(s2))
print(s1 & s2)# 与上面一行是等价的
'''并集'''
print(s1.union(s2))
print(s1|s2) #与上面是一样等价的

'''差集'''
print(s1.difference(s2))
print(s1-s2)

print(s1)
print(s2)

'''对称差集'''
print(s1.symmetric_difference(s2))
print(s1^ s2)

7.集合生成式

在这里插入图片描述


lst=[i*i for i in range(10)]
print(lst)

'''集合生成式'''
s={i*i for i in range(10)}
print(s)

sp:列表、字典、元组、集合总结

在这里插入图片描述

第九章一串连一串

0.本章总结

在这里插入图片描述

1.字符串驻留机制

在这里插入图片描述

在这里插入代码片a='python'
b="python"
c='''python'''
print(a,id(a))#1784692440496
print(b,id(b))#1784692440496
print(c,id(c))#1784692440496

2.字符串的常用操作

在这里插入图片描述

s='hello,hello'
print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rfind('lo'))#9
print(s.rindex('lo'))#9
#print(s.index('k'))#substring not found
print(s.find('k'))#-1
#print(s.rindex('k'))#substring not found
print(s.rfind('k'))#-1

在这里插入图片描述

s='hello,python'
a=s.upper()#转成大写之后，会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b-=s.lower()#转换之后，会产一个新的字符串对象
print(b,id(b))
print(s,id(s))
print(b==s)
print(b is s)#False
s2='hello,python'
print(s2.swapcase())

print(s2.title())

在这里插入图片描述

s='hello,python'
'''居中对齐'''
print(s.center(20,'*'))
'''左对齐'''
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))

'''右对齐，使用0进行填充'''
print(s.zfill((20)))
print(s.zfill(10))

在这里插入图片描述

s='hello world python'
lst=s.split()
print(lst)
s1='hello|world|python'
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))
print('---------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|',maxsplit=1))

在这里插入图片描述

s='hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4','张三_123'.isidentifier())

print('5','\t'.isspace())
print('6.','abc'.isalpha())
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())
print('9','123'.isdecimal())
print('10.','123四'.isdecimal())

print('11.','123'.isnumeric())
print('13.','123四'.isnumeric())
print('14','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc!'.isnumeric())

在这里插入图片描述

s='hello,python'
print(s.replace('python','java'))
s1='hello,python,python,python'
print(s1.replace('python','java',2))

lst=['hello',java,python]
print('|'.join(lst))
print('',join(lst))

t=('hello','java','python')
print('',join(t))

3.字符串的比较

在这里插入图片描述

print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(ord('杨'))

print(chr(97),chr(98))
print(chr(26472))

'''==与is的比较
==比较的是value
is 比较的是id是否相等'''
a=b='python'
c='python'
print(a==b)
print(b==c)

print(a is b)
print(a is c)
print(id(a))#2559352137840
print(id(b))#2559352137840
print(id(c))#2559352137840

4.字符串的切片比较

在这里插入图片描述

s='hello,python'
s1=s[:5]
s2=s[6:]
s3='!'
newtr=s1+s3+s2

print(s1)
print(s2)
print(newstr)
print('--------------------------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))
print('--------切片[start:end:step]----------------')
print(s[1:5:1])#从1开始截取到5（不包含5），步长为1
print(s[::2])
print(s[::-1])#默认从字符串最后一个元素开始，到字符串的第一个元素结束，因为步长是负数

5.格式化字符串

在这里插入图片描述

#(1) %占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))

#(2) {}
print('我叫{0}，今年{1}岁'.format(name,age))

#f-string
print(f'我叫{name},今年{age}岁')

print('%10d' % 99)
print('%.3f' % 3.1415926)
print('%10.3f' % 3.1415926)
print('hellohello')
print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))

6.字符串的编码转换

在这里插入图片描述

s='天涯共此时'
print(s.encode(encoding='GBK')) #一个中文占两个字节
print(s.encode(encoding='UTF-8'))#在UTF-8这种编辑格式中，一个中文占三个字节

#解码
#byte代表就是一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))

byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

第十章水晶球不调用不动

0.本章总结

在这里插入图片描述

1.函数的创建和调用

在这里插入图片描述

def calc(a,b):
    c=a+b
    return c

result=calc(10,20)
print(result)

2.函数的参数传递

在这里插入图片描述

3.函数的返回值

在这里插入图片描述

def fun(num):
    odd=[]#存奇数
    even=[]#存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
    1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】
    2）函数的返回值，如果是一个，直接返回类型
    3）函数的返回值，如果是多个，返回的结果为元组

'''

def fun1():
    print('hello')
    #return

fun1()

def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3()
    return 'hello','world'
print(fun3())

'''
函数在定义时，是否需要返回值，就视情况而定'''

4.函数的参数定义

在这里插入图片描述

def fun(a,b=10):
    print(a,b)

#函数的调用
fun(100)
fun(20,30)

print()

print('hello',end='\t')
print('world')

在这里插入图片描述

def fun(*args):
    print(args)
    #print(args[0])
fun(10)
fun(10,30)
fun(30,405,50)

def fun1(**args):
    print('hello','world','java')

#def fun2(*args,*a):#以上代码，程序会报错，因为可变参数只能是定义一个
#def fun2(**args,**args):#以上代码，程序会报错，因为可变参数只能定义一个

def fun2(*args1,**args2):#程序可以运行
    pass
#def fun2(**args1,*arg2)#报错
   # pass 在一个函数的定义过程中，既有个数可变的关键字形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前

在这里插入图片描述

def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=',b)
    print('c=',c)
#函数的调用
fun(10,20,30)#函数调用时的参数传递，称为位置传参
lst[11,22,33]
fun(lst)#错误
fun(*lst)#在函数调用时，将列表中的每一个元素都转换为位置实参传入
print('---------------')
fun('a=100,c=100,b=200')#函数的调用，所以是关键字实参
fun(**dic)#在函数调用的时候，将字典中的键值对都转换为关键字实参传入
print(-------------------------------------------------------)
def fun(a,b=10):#b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=',a)
    print('b=',b)

def fun2(*args):#个数可变的位置形参
    print(args)

def fun3(**args2):#个数可变的关键字形参
    print(args2)

fun2(10,20,30,40)#个数不限
fun3(a=11,b=22,c=33,d=44,e=55)#个数不限



def fun4(a,b,*,c,d):#从*之后的参数，在函数调用的时候，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#调用fun4 函数
#fun4(10,20,30,40)#位置实参传递
#fun4(a=10,b=20,c=30,d=40)#关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数，采用的是位置实参传递，而c,d采用的是关键字实参传递
'''需求，c、d只能采用关键字实参传递'''

'''函数定义时的形参的顺序问题'''
def fun5 (a,b,*,c,d,**args):#就可以这样定义
    pass
def fun6(*args,**args2):#就可以这样定义
    pass
def fun7(a,b=10,*args,**args2):#可以定义
    pass

5.变量的作用域

在这里插入图片描述

def fun(a,b):
    c=a+b
    print(c)

#print(c)#因为a,c超出了其本身作用的范围
#print(a)
name='杨老师'
print(name)
def fun2():
    print(name)
#调用函数
fun2()
def fun3():
    global age #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age=20
    print(age)


fun3()
print(age)

6.递归函数

在这里插入图片描述

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(6))

第十一章全民来找茬

0.本章总结

在这里插入图片描述

1.bug的由来及分类

在这里插入图片描述

try:
    a=int(int('请输入第一个整数'))
    b=int(input('请输入第二个整数'))
    result=a/b
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为0')
except ValueError:
    print('只能输入数字串')
print('程序结束')

在这里插入图片描述

try:
    a=int(input('请输入第一个整数'))
    b=int(input('请输入第二个整数'))
    result=a/b
    print('结果为：',result)
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)

在这里插入图片描述

try:
    a=int(input('请输入第一个整数'))
    b=int(input('请输入第二个整数'))
    result=a/b
    print('结果为：',result)
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('谢谢你的使用')

2.不同异常类型的处理方式

在这里插入图片描述

3.异常处理机制

在这里插入图片描述

import traceback
try:
    print('-----------')
    print(1/0)
except:
        traceback.print_exc()

4.pycharm的调式模式

在这里插入图片描述

第十二章找对象不积极思想有问题

0.本章总结

在这里插入图片描述

1.两大编程思想

在这里插入图片描述

2.类和对象的创建

在这里插入图片描述

class Student:
    native_pace='安徽'
    def__init__(self,name,age):
        self.name=name
        self.age=age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
    #在类之外定义的称为函数，在类之内定义的称为方法
    def drink():
        print('喝水')

在这里插入图片描述

class Student:
    native_place='安徽'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
    #在类之外定义的称为函数，在类之内定义的称为方法
    def drink():
        print('喝水')

#创建一个student类的对象
stu1=Student('张三',20)
print(id(stu1))
print(type(stu1))
print(stu1)

print('---------------------')
print(id(Student))
print(type(Student))
print(Student)
#调用
stu1=Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)
print('------------------')
Student.eat(stu1)#33行与28行代码功能相同，都是调用Student中的eat方法
                #类名.方法名（类的对象）-->实际上就是方法定义处的self

3.类对象与类属性

在这里插入图片描述

4.类方法与静态方法

在这里插入图片描述

class Student:
    native_place='安徽'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    #实例方法
    def eat(self):
        print('学生在吃饭...')


stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))
print(id(stu2))
print('----------为stu2动态绑定----------')
stu1.gender='女'
#print(stu1.name,stu1.age,stu1.gender)
print(stu1.name,stu1.age,stu1.gender)
print(stu2.name,stu2.age)

print('---------------')
stu1.eat()
stu2.eat()

def show():
    print('定义在类之外的，称函数')
stu1.show=show
stu1.show()

第十三章接着找对象

0.本章总结

在这里插入图片描述

1.封装

在这里插入图片描述

class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动。。')
car=Car('宝马x5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外使用name和age
print(stu.name)
#print(stu.__age)
print(dir(stu))#['_Student__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'show']
print(stu._Student__age)

2.继承

在这里插入图片描述

class Person(object): #person集成object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no

class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super.__init__(name,age)
        self.teachofyear=teachofyear

stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)


print('--------多继承----------')
class A(object):
    pass
class B(object):
    pass
class C(A,B):
    pass

3.方法重写(理解不了)

在这里插入图片描述

class Person(object): #person集成object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):
        super().info()
        print(self.stu_no)

class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super.__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):
        super().info()
        print('教龄',self.teachofyear)

stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)
print('-----------------')
stu.info()
teacher.info()

4.object类

在这里插入图片描述

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu))
print(stu)#默认调用__str__()这样的方法
print(type(stu))

对象中__str__描述

5.多态

在这里插入图片描述

6.特殊方法和特殊属性

在这里插入图片描述特殊属性：

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name):
        self.name=name
class D(A):
    pass
#创建C类的对象
x=C('Jack')#x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__)
print('-------------------')#<class '__main__.C'> 输出对象所属的类
print(x.__class__)#C类的父类类型的元素
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(C.__mro__)#类的层次结构
print(A.__subclasses__())#子类的列表

特殊方法;

a=20
b=100
c=a+b#两个整数类型的对象相加操作
d=a.__add__(b)

print(c)
print(d)

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)
stu1=Student('张三')
stu2=Student('李四')

s=stu1+stu2 #实现了两个对象的加法运算（因为student类中，编写__add__()特殊的方法）
print(s)
s=stu1.__add__(stu2)
print(s)
print('-------------------------------')
lst=[11,22,33,44]
print(len(lst))#len是内容函数len
print(lst.__len__())
print(len(stu1))

class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('__init__被调用了'，self的id值：{0}.format(id(self)))
        self.name=name
        self.age=age
print('object这个累对象的id为:{0}'.format(id(object)))
print('person这个类对象的id为：{0}'.format(id(person)))
#创建person类的实例对象
p1=person('张三',20)
print('p1这个person类的实例对象的id:{0}'.format(id(p1)))

在这里插入图片描述

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
#1)变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))

在这里插入图片描述

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
#1)变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
#(2)类有浅拷贝
print('-----------------------')
disk=Disk() #创建一个硬盘类的对象
computer=Computer(cpu1,disk)#创建一个计算机的对象

#浅拷贝
import copy
cpmputer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

深拷贝：
在这里插入图片描述

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
#1)变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
#(2)类有浅拷贝
print('-----------------------')
disk=Disk() #创建一个硬盘类的对象
computer=Computer(cpu1,disk)#创建一个计算机的对象

#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)

第十四章百宝箱

0.本章总结

在这里插入图片描述

1.什么叫模块

在这里插入图片描述模块包含函数，包含类（类中包含类属性，实例方法，类方法，静态方法），包含语句

2.自定义模块

在这里插入图片描述
方法一：导入模块中所有

import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('--------------------')
print(dir(math))
print(math.pow(2,3),type(math.pow(2,3)))
print(math.ceil(9.001))
print(math.floor(9.999))

方法二：导入模块中指定的方法

from math import pi
from math import pow
print(pi)
print(pow(2,3))
#print(math.pow(2,3))

自己定义的模块可以导入吗
先定义一个模块：
在这里插入图片描述
在新建一个程序文件.py，直接如下写会报错：
正确操作如下，先找到目录，在目录下，找到下面的步骤点好。
下面就可以正常使用了

3.以主程序的形式执行

在这里插入图片描述单独运行calc2，会输出print(add(10,20)).如果不加if…==…，那么在其他程序中调用时，这就会也输出这个calc2中的print(add(10,20))。加上后，意思是只有calc2是主程序时候，才会执行print(add(10,20))。

4.python中的包

在这里插入图片描述

怎样去借python的包：

以上建立包和建立目录的区别，如下是怎么写包

写好包以后，在别的程序中导入包：
在这里插入图片描述

在这里插入图片描述

5.第三方模块的安装以及使用

在这里插入图片描述
windows+R 输入cmd
输入pip install schedule

第十五章大宝藏

0.本章小结

在这里插入图片描述

1.编码格式介绍

在这里插入图片描述 #encoding=gbk ====>ANSI格式

2.文件的读写原理

在这里插入图片描述

3.文件的读写操作

在这里插入图片描述

file=open('a.txt','r')
print(file.readlines())
file.close()

在这里插入图片描述

4.文件对象常用的方法

在这里插入图片描述

5.with语句（上下文管理器）

在这里插入图片描述

with open('a.txt','r') as file:
	print(file.read())

with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())

6.目录操作

在这里插入图片描述
是一个python自带的一个模块。

da..

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
python语法学习

1.初了解1.1 print函数#用print输出数字print(520)print(98.5)#输出字符串print('helloworld')#引号告诉计算机不需要你理解，你照着输出就可以了#输出表达式print(3+1)#将数据输出到文件中，注意1.所指定的盘符存在，2.使用file*fpfp=open('D:/text.txt','a+')#a+如果文件不存在就创建，存在就在文件内容的后面继续追加print('helloworld',file=fp)#相当于print &gt
复制链接

扫一扫