Python基础语法

Python的安装

python的安装

1，去光网下载python安装包www.python.org/downloads/r… 下载红笔标记的

点击安装可执行文件直接点击下一步>下一步安装就行

安装完毕后电脑开始里面回多出一个文件夹

表示安装成功

pyChram安装和激活

1，安装

去官网下载安装包www.jetbrains.com/pycharm/dow…

选择专业版

点击下一步安装

勾选上面的选项 其他无脑点击下一步

2，pycharm激活

下载激活插件链接：pan.baidu.com/s/1PTj0E9Os… 提取码：8n02

具体激活步骤参考www.itmind.net/134027.html

Python的基本语法

print函数

print函数输出的内容

1. 数字
2. 字符串
3. 含有运算符的表达式

print函数输出的目的地

1. 显示器
2. 文件

print函数的输出形式

1. 换行
2. 不换行

转义字符

什么是转义字符？

反斜杠+想要转义功能的首字母

当字符串中包含反斜杠，单引号，和双引号等特殊用途的字符时，必须使用反斜杠对这些字符进行转义

换行 \n 回车 \r 水平制表 \t 退格 \b 原子符：不希望字符串的转义字符起作用，就使用原字符，就是在字符串之前加r或R（最后一个字符不能是反斜线）

标识符和保留字

保留字

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

标识符

• 字母，数字，下划线_
• 不能以数字开头
• 不能是保留字
• 严格区分大小写

变量

变量由三个部分组成

• 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
• 类型：表示对象的数据类型，使用内置函数type（obj）来获取
• 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出

name='张三'
print('id',id(name))
print('类型',type(name))
print('值',name)

当多次赋值后，变量名回指向新的空间

数据类型

常用的数据类型

• 整数类型 int->98
• 浮点数类型 float->3.1415926
• 布尔类型 bool->true false
• 字符串类型 str->'helloworld'

整数类型

• 英文integer 简写int，可以表示正数，负数，零
• 整数的不同进制表示方式
  1. 10进制默认
  2. 2进制 0b开头
  3. 8进制 0o开头
  4. 16进制 0x开头

浮点数类型

• 浮点数分为整数和小数部分组成
• 浮点数存储不精确性
  • 使用浮点数计算，可能回出现小数位不确定的情况
  • 解决方案
    • 导入模块decimal

from decimal import  Decimal
print(Decimal('1.1')+Decimal('2.2'))

布尔类型

• 用来表示真假的值
• True真 False假
• 布尔类型可以转化为整数
  • true 1
  • false 0

字符串数据类型

• 字符串又被称为不可变的字符序列
• 可以使用单引号 双引号 三引号 来定义
• 单引号和双引号定义的字符串必须在一行
• 三引号定义的字符串可以分布在连续的多行

数据类型转换

为什么需要数据类型转换？

• 将不同的数据类型的数据拼接在一起
  1. str()将其它类型转化为字符串类型
  2. int()将其它类型转化为整数类型
  3. float()将其它类型转化为浮点数类型

name='张三'
age=20
print('我叫'+name+'今年，'+str(age)+'岁')

s1='122'
f1=98.7
s2='123.2'
ff=True
s3='hello'
print(int(s1),type(s1))#将str转成int类型，字符串为数字串
print(int(f1),type(f1))#将float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2),type(s2))#将str转成int类型，报错，字符串为小数串
print(int(ff),type(ff))
print(int(s3),type(int(s3)))#将str转成int类型，报错，字符串必须为数字串（整数）

s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
# print(float(s3),type(float(s3)))#字符串中的非数字串，不允许转换
print(float(i),type(float(i)))

注释

注释的三种类型

• 单行注释： #开头，直到换行结束
• 多行注释： 并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
• 中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式#coding:utf-8

input()函数

# 输入两个整数，计算两个整数的和
a=int(input('请输入a：'))
b=int(input('请输入b：'))
print(a+b)

运算符

算数运算符

1. 标准运算符 加+ 减- 乘* 除/ 整除//
2. 取余运算符 %
3. 幂运算符 **

print(1+1)
print(1-1)
print(2*4)
print(2/4)
print(9//4)
print(9%4)
print(2**4)

print(-9//4)#一正一负整除，向下取整 -3
print(-9%4)#一正一负取余，余数=被除数-除数*商  3

赋值运算符=

1. 执行顺序：右->左
2. 支持链式赋值：a=b=c=20
3. 支持参数赋值：+= -= *= /= //= %=
4. 支持系列解包赋值：a,b,c=20,30,40

#链式赋值
a=b=c=20
print(a,id(a))
print(b,id(b))
print(c,id(c))
#支持参数赋值
a=20
a+=30
print(a)
a-=10
print(a)
a*=2
print(a)
a/=4
print(a)
a//=3
print(a)
#解包赋值
a1,b1,c1=20,30,40#左右变量个数不对应会报错
print(a1,b1,c1)
#交换两个变量的值
a,b=10,20
#交换
a,b=b,a
print(a,b)

比较运算符

对变量或表达式的结果进行大小，真假等比较

# print('-----------比较运算符---------')
a,b=10,20
print(a>b)
print(a<b)
#=赋值  ==比较运算符 ==比较的值   比较标识 is  is not不是
a,b=10,10
print(a==b)
print(a is b)
list1=[11,22,33]
list2=[11,22,33]
print(list1==list2)
print(list1 is  list2)
print(list1 is not list2)

布尔运算符

and, or ,not, in, not in

print('-----------布尔运算符---------')
print('------and并且---------')
a,b=1,2 #两个运算符都是True，运算符结果才为True
print(a==1 and b==2)# True and True> True
print(a==1 and b<2)# True and False> False
print(a!=1 and b==2)# False and True> False
print(a!=1 and b!=2)# False and False> False

print('------or或者---------')
#只要有一个为True，结果就是True
print(a==1 or b==2)#True or True>True
print(a==1 or b<2)#True or False>True
print(a!=1 or b==2)#False or True>True
print(a!=1 or b!=2)#False or False>False
print('------not取反---------')
f=True
print(not f)
print('------in，not in---------')
s='helloworld'
print('hello' in s)
print('zzz' not in s)

位运算符

将数据转换为二进制进行计算

1. 位与 &：对应的位都是1，结果数位才是1，否则为0
2. 位或 | ：对应数位都是0，结果数位才是0，否者为1
3. 左移位运算符 <<：高位溢出舍去，低位补0
4. 右移位运算符 >>：低位溢出舍去，高位补0

print('--------位运算符----------')
print(4&8)
print(4|8)
print(8<<2)
print(8>>2)

运算符的优先级

==（）>算术运算符>位运算符>比较运算符>布尔运算符>赋值运算符==

程序的组织结构

• 顺序结构
• 选择结构 if语句
• 循环结构 while for in语句

对象的布尔值

以下对象的布尔值为False

False 数值0 None 空字符串 空列表 空元组 空字典 空集合

print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(''))#False
print(bool(""))#False
print(bool([]))#空元组
print(bool(list()))#空列表
print(bool(()))#空元组
print(bool(tuple()))#空元组
print(bool({}))#空字典
print(bool(dict()))#空字典
print(bool(set()))#空集合
print('------------------以上对象的布尔值为False--------')

选择结构

1. 单分支结构

   '''
   语法结构
   if  条件表达式：
        条件执行体
   '''
   money=1000
   s=int(input('请输入金额'))
   if money>=s:
       money=money-s
   print('取款成功，余额为：',money)
   

2. 双分支结构

   '''
   语法结构
   if  条件表达式:
   	条件执行体1
   else:
   	条件执行体2
   '''
   print('----------双分支结构--------')
   num=int(input('请输入一个整数'))
   if (num%2)==0:
       print(num,'是偶数')
   else:
       print(num,'是奇数')
   '''
   语法结构
   if  条件表达式1:
   	条件执行体1
   elif 条件表达式2:
   	条件执行体2
   elif 条件表达式n:
   	条件执行体n
   [else:]
   	条件执行体n+1
   '''
   score=int(input('请输入一个成绩:'))
   if score>=90 and score<=100:
       print('A级')
   elif score>=80 and score<=89:
       print('B级')
   elif score>=70 and score<=79:
       print('C级')
   elif score>=60 and score<=69:
       print('D级')
   elif score>=0 and score<=59:
       print('E级')
   else:
       print('输出成绩是非法的!')
   

3. 嵌套结构

   '''
   	语法结构
   	if 条件表达式1:
   		if 内层条件表达式1:
   			内层条件执行体1
   		else:
   			内层条件执行体2
   	else:
   		条件执行体
   '''
   print('----------嵌套结构--------')
   answer=input('你是会员吗?y/n')
   money=float(input('请输入您的购物金额:'))
   if answer=='y':
       if money>=200:
           print('打8折，付款金额为：',money*0.8)
       elif money>=100:
           print('打9折，付款金额为：', money * 0.9)
       else:
           print('不打折，付款金额为：', money)
   
   else:
       if money>=200:
           print('打9.5折，付款金额为：', money * 0.95)
       else:
           print('不打折，付款金额为：', money)
   

4. 条件表达式

   '''
   	语法结构
   	x  if 判断条件 else y
   	判断条件为True，条件表达式返回值为x，否则条件表达式为y
   '''
   num1=int(input('请输入第一个整数'))
   num2=int(input('请输入第二个整数'))
   print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))
   

5. pass语句

   语句什么都不做，只是一个占位符，用在语法上需要语句的地方

   什么时候使用？

   先搭建语法结构，还没想好代码怎么写的时候

循环结构

内置函数range() 创建range对象的三种方法

1. range(stop) 创建一个[0，stop]之间的整数序列，步长为1
2. range(start,stop) 创建一[start,stop]之间的整数序列，步长为1
3. range(start,stop,step) 创建一个[start,stop]之间的整数序列，步长为step
4. 返回值是一个迭代器对象
5. range类型的优点，不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素

1. while循环

   '''
   语法结构
   while 条件表达式:
   	条件执行体(循环体)
   '''
   a=1
   while a<10:
       print(a)
       a+=1
   #选择结构的if与循环结构while的区别
   #if是判断一次，条件为True执行一行
   #while是判断N+1次，条件为True执行N次
   a=1
   sum=0
   while a<=100:
       if a%2==0:
           sum=sum+a
       a+=1
   print('和为',sum)
   

2. for-in循环

   in表达从（字符串，序列等）中依次取值，又称遍历

   for-in遍历的对象必须是可迭代对象

   for-in语法结构

   for自定义的变量in可迭代对象：

   ​ 循环体

   循环体内不需要访问自定义变量，可以将自定义变量替代为下划线

for item in 'python':
    print(item)

for i in range(10):
    print(i)

for _ in range(5):
    print('法外狂徒张三')

breake语句

用于结束循环结构，通常与分支结构if一起使用

for item in range(3):
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码错误 ')

a=0
while a<3:
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码错误 ')
    a+=1

continue语句

用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用

for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

else语句

与else语句配合使用的三种情况

1. if ... : else
2. while ... else
3. for ...: else

for item in range(3):
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码错误 ')
else:
    print('你的账户已被锁定')

嵌套循环

循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行

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

二重循环中的break和continue

二重循环中的break和continue用于控制本层循环

for i in range(5):
    for j in range(1,10):
        if j%2==0:
            break
        print(j)

for i in range(5):
    for j in range(1,10):
        if j%2==0:
            continue
        print(j,end='\t')
    print()

列表

为什么需要列表

1. 变量可以存储一个元素，而列表是一个“大容器"可以存储N多个元素，程序可以方便地对这些数据进行整体操作
2. 列表相当于其它语言中的数组

列表的创建

1. 列表需要使用中括号,元素之间使用英文的逗号进行分隔

2. 列表的创建方式

• 使用中括号

• 调用内置函数list()

  lst=['hello',1,2] lst1=list(['hello','world',1])

列表的特点

1. 列表元素按顺序有序排序
2. 索引映射唯一个数据
3. 列表可以存储重复数据
4. 任意数据类型混存
5. 根据需要动态分配和回收内存

列表的查询操作

获取列表中指定元素的索引

1. 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
2. 如果查询的元素在列表中不存在，则会抛出ValueError
3. 还可以在指定的start和stop之间进行查找

获取列表中的单个元素

1. 正向索引从O到N-1举例: Ist[0]
2. 逆向索引从-N到-1举例: lst[-N]
3. 指定索引不存，抛出IndexError

lst=['a','b','c']
lst1=list(['hello','world',1])
for i in lst:
    print(id(i))

print(lst.index('a'))
# print(lst.index('d'))
#print(lst.index('a',1,2))

print(lst[-1])

获取列表中的多个元素

语法格式

列表名 [start : stop : step]

切片操作

1. 切片的结果 -> 原列表片段的拷贝
2. 切片的范围 -> [start,stop)
3. step默认为1 -> 简写为[start:stop]
4. step为正数 -> 从start开始往后计算切片
   • [stop:step] -> 切片的第一个元素默认是列表的第一个元素
   • [start:step] -> 切片的最后一个元素默认是列表的最后一个元素
5. step为负数 -> 从start开始往前计算切片
   • [stop:step] -> 切片的第一个元素默认是列表的最后一个元素
   • [start:step] -> 切片的最后一个元素默认是列表的第一个元素

arr=[10,20,30,40,50,60,70,80]
print(arr[1:6:1])
print(arr[1:6])
print(arr[1:6:2])
print(arr[:6:2])#默认start=0
print(arr[1::2])#默认stop=列表长度
print('----------step步长为负数的情况------------')
print('原列表:',arr)
print(arr[::-1])
#start=7,stop 省略 step=-1
print(arr[7::-1])
#start=6,stop=0省略 step=-2
print(arr[6:0:-2])

判断指定元素在列表中是否存在

• 元素 in 列表名
• 元素 not in 列表名

列表元素的遍历

for 迭代变量 in 列表名： 操作

arr1=['hello','aloha',10,20,30]
print(10 in arr1)
print('hello' in arr1)
print(10 not in arr1)
for item in arr1:
    print(item)

列表元素的增加操作

1. append() 在列表的末尾添加一个元素
2. extend() 在列表的末尾至少添加一个元素
3. insert() 在列表的任意位置添加一个元素
4. 切片 在列表的任意位置添加至少一个元素

arr2=[10,20,30]
print('添加元素之前',arr2,id(arr2))
arr2.append(100)
print('添加元素之后',arr2,id(arr2))
arr3=['aloha','hello']
arr2.extend(arr3)
print(arr2)
arr2.insert(1,90)
print(arr2)
arr4=['sss','aaa']
arr2[1:]=arr4
print(arr2)

列表元素的删除操作

1. remove()
   • 一次删除一个元素
   • 重复元素只删除第一个
   • 元素不存在抛出ValueError
2. pop()
   • 删除一个指定索引位置上的元素
   • 指定索引不存在抛出IndexError
   • 不指定索引，删除列表中最后一个元素
3. 切片 一次致少删除一个元素
4. clear() 清空列表
5. del 删除列表

# 开发时间:2023/5/17 20:03
arr=[10,20,30,40,50,20,60]
arr.remove(20)
print(arr)
arr.pop(1)
print(arr)
arr.pop()
print(arr)
new_arr=arr[1:3]
print('原列表',arr)
print('切片后的列表',new_arr)
#不产生新的列表对象，而是删除原列表中的内容
arr[1:3]=[] #空列表替代该部分的元素
print(arr)
#清空列表
arr.clear()
print(arr)
#del将列表对象删除
del arr
print(arr)

列表元素的修改

• 为指定索引的元素赋予一个新值
• 为指定的切片赋予一个新值

arr1=[10,20,30]
arr1[2]=100
print(arr1)
arr1[1:3]=[300,400,500]
print(arr1)

列表元素的排序操作

1. 调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True,进行降序排序
2. 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变

arr2=[20,10,40,30,98,55]
print('排序前的列表',arr2)
arr2.sort()
print('排序后的列表',arr2)
arr2.sort(reverse=True)
print(arr2)

print('-----使用内置函数sorted()对列表进行排序,将产生新的列表对象-------')
arr3=[20,10,38,85]
new_arr3=sorted(arr3)
print(arr3)
print(new_arr3)
print('----')
#指定关键字，实现列表元素的降序排序
des_arr=sorted(arr3,reverse=True)
print(des_arr)

列表生成式

• 语法格式

  [i*i(表示列表元素的表达式) for i(自定义变量) in range(1,10)(可迭代对象)]

• 注意事项: 表示列表元素的表达式“中通常包含自定义变量”

  ==一般元素是有规律的==

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

字典

什么是字典？

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列
• scores={'张三':100,'李四':98}

字典的实现原理

字典的实现原理与查字典类似，查字典是先根据部首或拼音查找应的页码,Python中的字典是根据key查找value所在的位置

字典的创建

• scores={'张三':100,'李四':98}
• dict(name='jack',age=20)

scores={'张三':100,'李四':98}
print(scores,type(scores))

student=dict(name='jack',age=20)
print(student,type(student))

字典中获取元素

• [] scores['张三']
• get()方法 scores.get('张三')

student=dict(name='jack',age=20)
print(student['name'])
print(student.get('张三'))

字典的常用操作

1. key的判断

   • in 指定的key在字典中存在返回True
   • not in 指定的key在字典中不存在返回True

2. 字典的删除

   del scores['张三']

3. 字典的新增

   scores['jack']=90

student1={'张三':20,'李四':21,'王五':34}
print('张三' in student1)
print('张三' not in student1)
del student1['张三']
print(student1)
student1['老六']=23
print(student1)

字典中的视图操作

1. keys() 获取字典中所有key
2. values() 获取字典中的所有value
3. items() 获取字典中所有key，value对

student1={'张三':20,'李四':21,'王五':34}
print(student1.keys(),type(student1.keys()))
print(student1.values(),type(student1.values()))
print(student1.items(),type(student1.items()))

字典元素的遍历

for item in scores： print(item)

student2={'张三':20,'李四':21,'王五':34}
for item in student2:
    print(item,student2.get(item))

字典的特点

1. 字典中的所有元素都是一个key-value对, key不允许重复, value可以重复
2. 字典中的元素是无序的
3. 字典中的key必须是不可变对象
4. 字典也可以根据需要动态地伸缩
5. 字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

• 内置函数zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

• 字典生成式

  {item:age(表示字典key的表达式) for item(自定义的key对象),age(自定义的value对象) in zip(items,age)(可迭代对象)}

items=['张三','李四','王五']
age=[23,25,21]
d={item:age  for item,age in zip(items,age)}
print(d)

元组

python内置的数据结构之一，是一个不可变序列

不可变序列与可变序列

不可变序列：字符串，元组（没有增删改的操作） 可变序列：列表，字典 （可以对序列执行增删改操作，对象的地址不发生改变）

元组的创建方式

1. 直接小括号

   t=('python','hello',90)

2. 使用内置函数tuple()

   t=tuple(('python','hello',90))

3. 只包含一个元组的元素需要使用逗号和小括号

   t=(10,)

t=('python','hello',90)
print(t,type(t))

#省略小括号
t='python','hello',90
print(t,type(t))

t1=tuple(('python','hello',90))
print(t1,type(t1))

t2=('python',)
print(t2,type(t2))

#空元组
lst=[]
lst1=list()

d={}
d1=dict()

k=()
k1=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',k,k1)

为什么把元组设计为不可变序列

1. 在多任务环境下，同时操作对象时不需要加锁
2. 因此,在程序中尽量使用不可变序列
3. 注意事项:元组中存储的是对象的引用
   • a)如果元组中对象本身不可变对象，则不能再引用其它对象
   • b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

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]))
print(id(100))
#t[1]=100 #元组不允许修改元素
#由于[20，30]，列表,而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变
t[1].append(100)
print(t,id(t[1]))

元组的遍历

元组是可迭代对象，所以可以使用for......in进行遍历

for item in t:
    print(item)

集合

什么是集合？

• Python语言提供的内置数据结构
• 与列表、字典—样都属于可变类型的序列
• 集合是没有value的字典

集合的创建方式

• 直接{}

  s={'python','hello',90}

• 使用内置函数set()

s={2,3,3,4,4,5}#集合中的元素不允许重复
print(s)

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

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

s3=set((1,2,4,4,6,3))
print(s3,type(s3))

集合的相关操作

1. 集合元素的判断操作
   • in或not in
2. 集合元素的新增操作
   • 调用add()方法，一次添加一个元素
   • 调用update()方法至少添加一个元素
3. 集合元素的删除操作
   • 调用remove()方法，一次删除一个指定 元素，如果指定的元素不存在抛出KeyError
   • 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常
   • 调用pop()方法，一次只删除一个任意元素
   • 调用clear()方法,清空集合

#集合元素的判断操作
s3={10,20,40,60,90}
print(10 in s3)
print(100 in s3)
print(10 not in s3)
print(100 not in s3)
#集合元素的新增操作
s3.add(80)
print(s3)
s3.update({200,400,300})
print(s3)
#集合元素的删除操作
s3.remove(200)
s3.discard(500)
print(s3)
s3.pop()
print(s3)
s3.clear()
print(s3)

两个集合的关系

1. 两个集合是否相等
   • 可以使用运算符==或!=进行判断
2. 一个集合是否是另一个集合的子集
   • 可以调用方法issubset进行判断
   • B是A的子集
3. 一个集合是否是另一个集合的超集
   • 可以调用方法issuperset进行判断
   • A是B的超集
4. 两个集合是否没有交集
   • 可以调用方法isdisjoint进行判断

s={10,30,20}
s1={20,30,10}
print(s==s1)
print(s!=s1)
#集合是否是另一个集合的子集
a1={10,20,30,40}
a2={10,20}
a3={10,30,90}
print(a2.issubset(a1))
print(a3.issubset(a1))
#一个集合是否是另一个集合的超集合
print(a1.issuperset(a2))
print(a1.issuperset(a3))
#两个集合是否有交集
print(a2.isdisjoint(a3))#有交集False
a4={400,500}
print(a2.isdisjoint(a4))#没有交集True

集合的数学运算

#集合的数学运算
#交集
s1={10,20,30,40}
s2={20,30,60,90}
print(s1.intersection(s2))
print(s1 & s2)
#并集
print(s1.union(s2))
print(s1 | s2)
#差集操作
print(s1.difference(s2))
print(s1-s2)
#对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

集合的生成式

1. 用于生成集合的公式

   {i*i for i in range(1,10)}

   i*i:表示集合元素的表达式 i:自定义变量 range:可迭代对象

2. 将{}修改为[}就是列表生成式

3. 没有元组生成式

#列表生成式
lst=[ i*i for i in range(10)]
print(lst)

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

字符串

在Python中字符串是基本数据类型，是一个不可变的字符序列

什么叫字符串驻留机制？

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

驻留机制的几种情况

• 字符串的长度为0或1时
• 符合标识符的字符串
• 字符串只在编译时进行驻留，而非运行时
• [-5,256]之间的整数数字

sys中的intern方法强制2个字符串指向同一个对象 PyCharm对字符串进行了优化处理

字符串的驻留机制

1. 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
2. 在需要进行字符串拼接时建议使用str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高

字符串的查询操作

1. index() ：查找子串substr第一次出现的位置,如果查找的子串不存在时，则抛出ValueError
2. rindex() ：查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
3. find() ：查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1
4. rfind() ：查找子串substr最后一次出现的位置,如果查找的子串不存在时，则返回-1

#字符串的查找
s='hello,hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rindex('lo'))
#print(s.index('k'))
print(s.find('k'))
print(s.rfind('k'))

字符串的大小写转换操作方法

1. upper()：把字符串中所有字符都转成大写字母lc
2. lower()：把字符串中所有字符都转成小写字母
3. swapcase()：把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母
4. capitalize()：把第一个字符转换为大写，把其余字符转换为小写
5. title()：把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

#字符大小转换
s='hello,python'
a=s.upper()#转成大写后产生新的字符串
print(a,id(a))
print(s,id(s))
print(s.lower(),id(s.lower()))
print(s,id(s))

s2='hello,PYTHON'
print(s2.swapcase())
print(s2.title())

字符串内容对齐的方法

1. center()：居中对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串
2. ljust()：左对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
3. rjust()：右对齐,第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度则则返回原字符串
4. zfill()：右对齐，左边用0填充,该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

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(10))
print(s.rjust(20))

print(s.zfill(20))
print(s.zfill(10))
print('-124'.zfill(8))

字符串的分割

1. split()
   • 从字符串的左边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
   • 以通过参数sep指定劈分字符串是的劈分符
   • 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
2. rsplit()
   • 从字符串的右边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
   • 以通过参数sep指定劈分字符串是的劈分符
   • 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分

#字符串的分割
s='hello world python'
lst=s.split()
print(lst)
s1='hello|world|python'
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))

print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|',maxsplit=1))

判断字符串方法

1. isidentifier()：判断指定的宝符串是不是合法的标识符
2. isspace()：判断指定的字符串是否全部由空白字符组成(回车、换行，水平制表符)
3. isalpha()：判断指定的字符串是否全部由字母或汉字组成
4. isdecimal()：判断指定字符串是否全部由十进制的数字组成
5. isnumeric()：判断指定的字符串是否全部由数字组成
6. isalnum()：判断指定字符串是否全部由字母和数字组成

s2='hello,python'
print('1,',s2.isidentifier())
print('2,','s_2张三'.isidentifier())
print('3,','\t'.isspace())
print('4,','abs'.isalpha())
print('5,','张三'.isalpha())
print('6,','123'.isdecimal())
print('7,','123四'.isdecimal())
print('8,','123四'.isnumeric())
print('9,','ⅠⅡ'.isnumeric())
print('10,','abc1'.isalnum())
print('11,','张三123'.isalnum())
print('12,','abc!'.isalnum())

字符串的其他操作

1. replace()：第1个参数指定被替换的子串，第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串，替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
2. join()：将列表或元组中的字符串合并成一个字符串

s3='hello,python'
print(s3.replace('python','java'))
s3='hello,python,python,python'
print(s3.replace('python','java',2))
lst=['hello','zhangsan']
print('|'.join(lst))

字符串的比较操作

1. ==运算符==:>,>=,<,<=,==,!=
2. ==比较规则==:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
3. ==比较原理==:两上字符进行比较时，比较的是其ordinal value(原始值)调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符

print('a'>'b')#比较的是Ascall码
a=b='python'
print(a is b)#比较的是id
print(a == b)#比较的是value

字符串的切片操作

字符串是不可变类型

• 不具备增、删、改等操作
• 切片操作将产生新的对象

s4='hello,python'
a1=s4[:5]
a2=s4[6:]
print(a1)
print(a2)
print(a1+'!'+a2)
print(s4[::-1])

格式化字符串

格式化字符串的两种方式

• %作占位符
• {}作占位符

#%占位符
name='张三'
age=20
print('我叫%s，今年%d岁'%(name,age))
#{}
print('我叫{0}，今年{1}岁'.format(name,age))
#f-string
print(f'我叫{name}，今年{age}岁')
print('%10d' % 90)#10表示宽度
print('%.3f' % 3.1415926)
print('%10.3f' % 3.1415926)
print('{0:.3}'.format(3.1415026))#3表示的是一共是3位数
print('{:.3f}'.format(3.1415026))#3表示的是一共是3位小数
print('{:10.3f}'.format(3.1415926))

字符串的编码转换

编码与解码的方式

• 编码:将字符串转换为二进制数据(bytes)
• 解码:将bytes类型的数据转换成字符串类型

b='海上升明月'
#编码
print(b.encode(encoding='GBK'))#gbk一个中文占两个字节
print(b.encode(encoding='UTF-8'))#UTF-8一个中文占三个字节
#解码
byte=b.encode(encoding='GBK')#gbk一个中文占两个字节
print(byte.decode(encoding='GBK'))

函数

1. 什么是函数

   函数就是执行特定任和以完成特定功能的一段代码

2. 为什么需要函数

   • 复用代码·隐藏实现细节
   • 提高可维护性
   • 提高可读性便于调试

3. 函数的创建 def 函数名（[输入参数]) : 函数体 [return xxx]

函数的创建和调用

#函数的创建
def calc(a,b):
	c=a+b
 	return c
#函数的调用
result=calc(10,20)
print(result)

函数的参数传递

1. 位置实参

   根据形参对应的位置进行实参传递

2. 关键字实参

   根据形参名称进行实参传递

def fun(arg1,arg2):
    print('arg1:',arg1)
    print('arg2',arg2)
    arg1=100
    arg2.append(10)
    print('arg1:', arg1)
    print('arg2', arg2)

n1=11
n2=[22,33,44]
print('n1:',n1)
print('n2:',n2)
fun(n1,n2)
print('n1:',n1)
print('n2:',n2)
#如果是不可变对象，在函数体的修改不会影响实参的值
#如果是可变对象，在函数体的的修改会影响到实参的值

函数的返回值

函数返回多个值，结果位元组

def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[10,33,45,6,7,99,24]
print(fun(lst))
'''
函数的返回值
(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写
(2)函数的返回值，如果是1个，直接返回类型
(3)函数的返回值，如果是多个，返回的结果为元组
'''

函数参数的定义

1. 函数定义默认值参数

   函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

2. 个数可变的位置参数

   • 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
   • 使用*定义个数可变的位置形参
   • 结果为一个元组

3. 个数可变的关键字形参

   • 定义函数时，无法事先确定传递的关键字实参的个数时使用可变的关键字形参
   • 使用**定义个数可变的关键字形参
   • 结果为一个字典

   ​

def fun1(*args):
    print(args)
fun1(10)
fun1(10,20,30)

def fun2(**args):
    print(args)
fun2(a=10)
fun2(a=20,b=30,c=40)
'''
def fun2(*args,*a):
    pass
    以上代码，程序会报错，个数可变的位置参数，只能是1个
def fun2(**args,**args):
    pass
以上代码，程序会报错，个数可变的关键字参数，只能是1个
'def fun3(**args1, *arg2):
pass
在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
'''

函数的参数总结

def fun3(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fun3(10,20,30)
lst=[11,22,33]
fun3(*lst)#函数调用时，将列表中的每个元素都转换为位置实参传入
print('-------------------')
dic={'a':111,'b':222,'c':333}
fun3(**dic)#在函数调用时，将字典中的键值对都转换为关键字实参传入
def fun4(a,b=10):
    print('a=',a)
    print('b=',b)
def fun5(*args):
    print(args)
def fun6(**args1):
    print(args1)
fun5(10,30,50)
fun6(a=11,b=22,c=40)
def fun7(a,b,c,d):#*之后的参数，函数调用时只能采用关键字实参传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
fun7(10,20,30,40)#位置实参传递
fun7(a=10,b=20,c=30,d=70)#关键字实参传递
fun7(2,40,c=50,d=90)#前两个参数，采用的是位置实参传递，而从从c，d采用的是关键字实参传递

变量的作用域

• 程序代码能访问该变量的区域

• 根据变量的有效范围可分为

  局部变量

  ​ 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会就成全局变量 全局变量 ​ 函数体外定义的变量，可作用于函数内外

def fun8(a,b):
    c=a+b#c局部变量
    print(c)
#print(c)
name='张三'
print(name)
def fun9():
    print(name)
fun9()
def fun10():
    global age#局部变量使用global就变成全局变量
    age=20
    print(age)
fun10()
print(age)

递归函数

什么是递归函数 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数 递归的组成部分 递归调用与递归终止条件公 递归的调用过程 每递归调用一次函数，都会在栈内存分配一个栈帧，·每执行完一次函数，都会释放相应的空间 递归的优缺点 缺点:占用内存多，效率低下 优点:思路和代码简单

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

def fib(n):
    if(n==1):
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(6))

异常处理

多个except结构 捕获异常的顺序按照先子类后父亲类的顺序,为了避免遗漏可能出现的异常，可以在最后增加BaseException

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

try....except...else结构

如果try块中没有抛出异常，则执行else块,如果try中抛出异常，则执行except块

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

try....except....else....finally结构

finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源

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

python常见的异常类型

traceback模块

使用traceback模块打印异常信息

import traceback
try:
    print('---------------')
    print(1/0)
except:
    traceback.print_exc()
# ---------------
# Traceback (most recent call last):
#   File "D:\python\demo11.py", line 55, in <module>
#     print(1/0)
# ZeroDivisionError: division by zero

类和对象

类是多个类似事物组成的群体的统称，能够帮助我们快速理解和判断事物的性质

创建类的语法

class Student: pass

class Student:#每个单词的首字母大写，其余字母小写
    pass
print(id(Student))
print(type(Student))
print(Student)

类的组成

• 类的属性
• 实例方法
• 静态方法
• 类方法

class Student:#每个单词的首字母大写，其余字母小写
    native_pace='杭州'#直接写在类里的变量，称为类属性
    #初始化方法
    def __init__(self,name,age):
        self.name=name #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋值给实体属性
        self.age=age

    #实例方法
    def eat(self):
        print('学生在吃饭....')
    #静态方法
    @staticmethod
    def method():
        print('我是静态方法.....')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法.....')

对象的创建

对象的创建又称为类的实例化 语法： 实例名=类名（） 例子： stu=Student（） 意义：有了实例，就可以调用类中的内容

class Student:#每个单词的首字母大写，其余字母小写
    native_pace='杭州'#直接写在类里的变量，称为类属性
    #初始化方法
    def __init__(self,name,age):
        self.name=name #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋值给实体属性
        self.age=age

    #实例方法
    def eat(self):
        print('学生在吃饭....')
    #静态方法
    @staticmethod
    def method():
        print('我是静态方法.....')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法.....')

stu=Student('张三',24)
print(id(stu))
print(type(stu))
stu.eat()
print(stu.name)
print(stu.age)
Student.eat(stu)#类名.方法名(类的对象)实际上就是方法定义处的self

#实例方法的两种调用方式
stu=Student()
stu.eat()
Student.eat(stu)

1. 类属性:类中方法外的变量称为类属性，被该类的所有对象所共享

2. 类方法:使用@classmethod修饰的方法，使用类名直接访问的方法

3. 静态方法:使用@staticmethod修饰的主法，使用类名直接访问的方法

   print(Student.native_pace) Student.cm() Student.method()

动态的绑定属性和方法

print('----------为stu2动态的绑定性别属性---------------')
stu2.gender='女'
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender)
print('-------------------------')
stu1.eat()
stu2.eat()
print('----------为stu2动态的绑定方法---------------')
def show():
    print('定义在类之外的，称函数')
stu1.show=show
stu1.show()

面向对象

1. 封装:提高程序的安全性
   • 将数据（属性）和行为(方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
   • 在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个”_”。
2. 继承:提高代码的复用性
3. 多态:提高程序的可扩展性和可维护性

封装

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age#年龄不希望在类的外部被使用，所以加了两个_
    def show(self):
        print(self.name,self.__age)
stu=Student('张三',23)
stu.show()
#在类的外使用name与age
print(stu.name)
# print(stu.__age)
print(dir(stu))
print(stu._Student__age)

继承

语法格式 class 子类类名（父类1，父类2）： pass 如果一个类没有继承任何类，则默认继承objectPython支持多继承 定义子类时,必须在其构造函数中调用父类的构造函数

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,number):
        super().__init__(name, age)
        self.number=number
class Teacher(Person):
    def __init__(self, name, age,teacherAge):
        super().__init__(name,age)
        self.teacherAge=teacherAge

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

stu.info()
teacher.info()

方法重写

• 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)进行重新编写
• 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

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,number):
        super().__init__(name, age)
        self.number=number
    def info(self):
        super().info()
        print(self.number)
        
class Teacher(Person):
    def __init__(self, name, age,teacherAge):
        super().__init__(name,age)
        self.teacherAge=teacherAge
    def info(self):
        super().info()
        print(self.teacherAge)
stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)

stu.info()
teacher.info()

Object类

• object类是所有类的父类，因此所有类都有object类的属性和方法。
• 内置函数dir()可以查看指定对象所有属性
• Object有一个__str__()方法，用于返回一个对于“对象的描述",对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str__()进行重写

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)
print(type(stu))

多态

​ 简单地说，多态就是“具有多种形态"，它指的是:即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法

静态语言实现多态的三个必要条件

• 继承
• 方法重写
• 父类引用指向子类对象

动态语言的多态崇尚"鸭子类型"当看到一只鸟走起来像鸭子、游泳起来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心 对象是什么类型,到底是不是鸭子，只关心对象的行为

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头。。。')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person:
    def eat(self):
        print('人吃五谷杂粮')
def fun(obj):
    obj.eat()

fun(Cat())
fun(Dog())
fun(Animal())
fun(Person())

特殊属性

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

特殊方法

a=20
b=100
d=a.__add__(b)
print(d)
class stu:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name
stu1=stu('张三')
stu2=stu('李四')
s=stu1+stu2#在stu类中编写了特殊的方法__add__()
print(s)
s1=stu1.__add__(stu2)
print(s1)
print('-------------')
lst=[11,22,33,44]
print(len(lst))
print(lst.__len__())

class per(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('per这个类对象的id为：{0}'.format(id(per)))

#创建per实例对象
p=per('张三',20)
print('p这个per类对象的id为：{0}'.format(id(p)))

浅拷贝和深拷贝

• 变量的赋值操作

  只是形成两个变量，实际上还是指向同一个对象

• 浅拷贝

  Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象

• 深拷贝

  使用copy模块的deepcopy函数递归的拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

class cpu:
    pass
class disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
cpu1=cpu()
cpu2=cpu1
print(cpu1)
print(cpu2)
print('-------浅拷贝-------')
disk1=disk()
computer=Computer(cpu1,disk1)

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

模块

• 模块英文为Modules

• 函数与模块的关系

  一个模块中可以包含N多个函数

• 在Python中一个扩展名为.py的文件就是一个模块

• 使用模块的好处

  1. 方便其它程序和脚本的导入并使用
  2. 避免函数名和变量名冲突
  3. 提高代码的可维护性
  4. 提高代码的可重用性

自定义模块

创建模块

新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同

导入模块

import 模块名 [as 别名] from 模块名称 import 函数/变量/类

import math
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2,5))
print(math.ceil(9.00001))
print(math.floor(9.9999))

from math import pi
print(pi)
#导入别人的模块
def add(a,b):
    return a+b

import module1
print(module1.add(1,2))

以主程序形式运行

在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量的值为__main__

def add(a,b):
    return a+b

if __name__ == '__main__':
    print(add(10,20))#只有当点击运行moudule1时才会执行
    
import module1
print(module1.add(1,2))

包

• 包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下

• 作用:

  代码规范

  避免模块名称冲突

• 包与目录的区别

  包含__init__.py文件的

  目录称为包·目录里通常不包含_init_.py文件

• 包的导入

  import 包名.模块名

import pageage1.moduleA as num
print(num.a)
#使用import方式进行导入时，只能跟包名或模块名
from pageage1 import moduleA
#使用from。。。。import可以导入包 模块 函数 变量

常用的内置模块

import sys
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
import time
print(time.time())
print(time.localtime(time.time()))

import urllib.request
print(urllib.request.urlopen('http://www.baidu.com').read())

第三方模块的安装及使用

pip install 模块名 import 模块名

import schedule
import time
def job():
    print('哈哈。。。。。')
schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

文件

编码格式

文件的读写操作

file=open('a.txt','r',encoding='utf-8')
print(file.readlines())#读取文件中的所有内容放到一个列表里面
file.close()

常用的文件打开模式

• 按文件中数据的组织形式，文件分为以下两大类
  1. 文本文件:存储的是普通“字符"文本，默认为unicode字符集，可以使用记本事程序打开
  2. 二进制文件:把数据内容用“字节"进行存储,无法用记事本打开必须使用专用的软件打开，举例: mp3音频文件,jpg图片.doc文档等

1. r：以只读模式打开文件，文件的指针将会放在文件的开头
2. w：以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头
3. a：以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾
4. b：以二进制方式打开文件，不能单独使用，需要与共它模式一起使用，rb，或者wb
5. +：以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+

file=open('a.txt','r',encoding='utf-8')
print(file.readlines())#读取文件中的所有内容放到一个列表里面
file.close()

file=open('b.txt','w')
file.write('Python')
file.close()

file=open('b.txt','a')
file.write('Python')
file.close()

src_file=open('logo.jpg', 'rb')
target_file=open('copylogo.jpg','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()

文件对象的常用方法

file=open('a.txt','r',encoding='utf-8')
print(file.read(2))
print(file.readline())
print(file.readlines())
file.close()

file=open('a.txt','a')
lst=['java','hello']
file.writelines(lst)
file.close()

file=open('a.txt','r',encoding='utf-8')
file.seek(3)
print(file.read())
file.close()

file=open('b.txt','r',encoding='utf-8')
file.seek(3)
print(file.read())
print(file.tell())
file.close()

with语句

with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确的关闭，以此来达到释放资源的目的

with open('a.txt','r',encoding='utf-8') as file:
    print(file.read())

class MyContentMgr(object):#该类遵守了上下文管理器协议，该类的实例对象，称为上下文管理器对象
    def __enter__(self):
        print('enter方法被调用了')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit方法被调用了')

    def show(self):
        print('show方法被调用执行了')

with MyContentMgr() as  file:
    file.show()

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

目录操作

os模块是Python内置的与操作系统功能和文件系统相关的模块该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行,得到的结果可能不一样。 os模块与os.path模块用于对目录或文件进行操作

import os#os模块与操作系统相关的一个模块
# os.system('notepad.exe')
# os.system('calc.exe')
# #直接调用可执行文件
# os.startfile('D:\\software\\QQ\\install\\Bin\\QQ.exe')
print(os.getcwd())
#os.mkdir('newdir')
lst=os.listdir('../file')

print(lst)
#os.makedirs('A/b/c')
#os.rmdir('newdir')
os.removedirs('A/b/c')

os.path操作目录的相关函数

import os.path
print(os.path.abspath('demo3.py'))
print(os.path.exists('demo3.py'),os.path.exists('demo10.py'))
print(os.path.join('E:\\python','demo3.py'))
print(os.path.split('E:\\python\\demo13.py'))
print(os.path.basename('E:\\python\\demo13.py'))
print(os.path.dirname('E:\\python\\demo13.py'))
print(os.path.isdir('E:\\python\\demo13.py'))

import os
path=os.getcwd()
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)