【python】-【】

这篇具有很好参考价值的文章主要介绍了【python】-【】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

python安装

idle:python自带的简单的开发环境

输出函数print()

一、print会输出

  1. 数字
  2. 字符串(必须加引号)
  3. 含有运算符的表达式(例如 3+1 其中3,1是操作数,+是运算符)(进行运算)
#输出数字
print (98.5)

#输出字符串
print ("Hello, clovershrub")
print('hello,world')

#输出表达式
print(3+1)

二、print()函数还可以将内容输出的目的地

  1. 显示器
  2. 文件:
fp=open(‘D:/text.txt’,”a+)#文件不存在就创建,存在就在文件内容后面继续追加
print(‘helloworld‘,file=fp)
fp.close()

注意:所指定的盘符存在,使用file=fp
三、print()函数的输出形式

  1. 换行
  2. 不换行:使用,分割,print(‘hello’,’world‘,’Python‘)

转义字符和原字符

+转义功能的首字母

换行:\n(newline)

回车:\r (return)print(‘hello\rworld’)         在hello的下一行输出world

水平制表符:\t (tab)print(‘hello\tworld’)     输出 hello  world

而print(helloooo\tworld)  输出helloooo  world

因为hell这四个字母成为一个字表位,o后\t 占用了其余三个

若是无剩余 则会新开一个字表位

退格:\b (backspace)print(‘hello\bworld’)          退格输出hellworld

*原字符:不希望字符串中转义字符起作用,就会使用原字符,即在字符串上加上R或者r
如print(r‘hello\nworld’)         输出hello\nworld

二进制与字符编码

8bit(位) — 1 byte (字节)——256种状态——256种符号
1024byte——1KB
1024KB——1MB
1024MB——1GB
1024GB——1TB

标识符和保留字

一、保留字:被赋予了特殊意义,无法在对象起名中使用

  1. 新建 keyword.demo
  2. import(导入) keyword
  3. print(keyword.kwist) 输出关键字列表
    【python】-【】,Java,python,网络,microsoft
    二、变量/函数/类/模块和其他对象 所起的名字叫做标识符
    三、规则:
  4. 字母、数字、下划线
  5. 不能以数字开头
  6. 不能是保留字
  7. 须严格区分大小写

变量的定义和使用

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

数据类型

整数类型—int ——98,可以表示正数、负数、0
浮点数类型——float ——3.1415926
布尔类型——bool——True 、False
字符串类型——str——“人生苦短,我用Python”(加上引号就是,不管是单引号、双引号、三引号、都是字符串)

整数类型

一、整数不同进制的表示方式

  1. 十进制——默认
  2. 二进制——以0b开头
  3. 八进制——以0o开头
  4. 十六进制——以0x开头

【python】-【】,Java,python,网络,microsoft

浮点类型

【python】-【】,Java,python,网络,microsoft

布尔类型

【python】-【】,Java,python,网络,microsoft

字符串

【python】-【】,Java,python,网络,microsoft

类型转换

【python】-【】,Java,python,网络,microsoft

str()

与其他语言不同的是,字符串和其他数据类型通过“+”连接时,其他数据类型不会自动转换为字符串,而是报错,解决办法就是进行类型转换
【python】-【】,Java,python,网络,microsoft

a=10

b=198.8

c=False

printtype(a),type(b),type(c))
# 输出:<class ‘int’><class ‘float’> <class ‘bool’>

printstr(a),str(b),str(c),type(a),type(b),type(c))
# 输出:10 198.8 False <class ‘str’> <class ‘str’> <class ‘str’> 

int()

将str转为int类型,str必须是整数串,否则会报错,float转int会截取float的整数部分

s1='128'
f1=98.7
s2="45.6"
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))) #字符串为小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #字符串必须为数字串且为整形

float()

  1. 非数字串不允许转换
  2. 布尔值true转1.0,false转0.0
s1='128.98'
s2="76"
ff=True
s3="hello" 
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))# 128.98
print(float(s2),type(float(s2)))# 76.0
print(float(ff),type(float(ff)))# 1.0
#print(float(s3),type(float(s3))) #非数字串不允许转换
print(float(i),type(float(i))) # 98.0

注释

含有三种类型的注释

  1. 单行注释——以#开头,直到换行结束
  2. 多行注释——一对三引号代码 多行注释
'''多行注释
多行哦'''
  1. 中文编码声明注释——在文件开头 以指定源码文件的编码格式

【python】-【】,Java,python,网络,microsoft

input函数的使用

【python】-【】,Java,python,网络,microsoft
input()接收的参数是程序对用户的提问,会将用户的输入赋值给present变量
【python】-【】,Java,python,网络,microsoft

#输入函数input
prasent=input('大圣想要什么礼物呢?')
print(prasent,type(prasent))# 输出:用户键盘输入的内容,类型为str

# 从键盘录入两个整数,计算两个整数的和
a=int(input('请输入一个加数:'))
b=int(input('请输入一个被加数:'))
print(type(a),type(b))
print(a+b)
#print(int(a)+int(b))

运算符

python中运算符:算术运算符、赋值运算符、比较运算符、布尔运算符、位运算符

算数运算符

标准算术运算符:+、-、*、/、整除//
取余运算符:%
幂运算符:**

print(1+1) #加
print(1-1) #减
print(2*4) #乘
print(11/2) #除
print(11//2) #整除运算
print(11%2) #取余
print(2**3) #幂运算 2的3次方

print(9//4)# 2
print(-9//-4)# 2
#一正一负进行整除时,向下取整
print(9//-4)# -3
print(-9//4)# -3

# 一正一负进行取余时,遵循公式:公式 余数=被除数-除数*商
print(9%-4)# 9-(-4)*(-3) 9-12-->-3
print(-9%4)# -9-4*(-3) -9+12-->3 

赋值运算符

【python】-【】,Java,python,网络,microsoft

a=3+4
print(a)# 7
b=c=d=20
# 以下3个输出都是同一个值
print(d,id(d))# 14645450672
print(b,id(b))# 14645450672
print(c,id(c))# 14645450672

a=20
a+=30
print(a)# 50
a*=2
print(a)# 100
a/=30
print(a)#3.33333333
a%=3
print(a)# 0.11111111

# 支持系列解包赋值,变量个数和值的个数一定要一致,否则会报错
a,b,c=1,2,3
print(a,b,c)# 1,2,3
# 系列解包赋值的用处:交换两个变量
a,b=10,20
print('交换前',a,b)# 10,20
a,b=b,a
print('交换后',a,b)# 20,10

比较运算符

【python】-【】,Java,python,网络,microsoft
比较运算符的结果是布尔类型

a,b=10,20
print('a>b吗?',a>b)
print(a<b)
print(a<=b)
print(a>=b)
print(a==b)# false
print(a!=b)# true

a=10
b=10
print(a==b) #True 说明,a与b的value相等
print(a is b) #True 说明:a与b的id标识相等
print(a is not b)# false

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)# true
print(lst1 is lst2 )# false
print(id(lst1))# 2525441564
print(id(lst2))# 2525665484
print(lst1 is not lst2)# true

布尔运算符

【python】-【】,Java,python,网络,microsoft

a,b=1,2
print(a==1 and b==2)# true
print(a==1 and b<2)# false
print(a!=1 and b==2)# false
print(a!=1 and b!=2)# false

print(a==1 or b==2)# true
print(a==1 or b<2)# true
print(a!=1 or b==2)# true
print(a!=1 or b!=2)# false

#not 对bool类型操作数取反
f=True
f2=False
print(not f)# false
print(not f2)# true

s='helloworld'
print('w' in s)# true
print('k' in s)# false
print('w' not in s)# false
print('k' not in s)# true

位运算

【python】-【】,Java,python,网络,microsoft

print(4&8) # 输出0。按位与&,同时为1结果为1
print(4|8) # 输出12。按位或|,同时为0结果为0
print(4<<1) # 输出8。向左移动1位 相当于乘以2
print(4<<2) # 输出16。向左移动2位
print(4>>1) # 输出2。向右移动1位,相当于除以二
print(4>>2) # 输出1。除以4

运算符的优先级

总结:()、算术运算、位运算、比较运算、bool运算、赋值运算

  1. ()
  2. ** A 赋值运算符:先乘除后加减,有幂运算先幂运算
  3. *、/、//、%
  4. +、-
  5. <<、>> B 位运算符
  6. &
  7. |
  8. 、< 、>=、<=、==、!= C 比较运算符

  9. and
  10. or D 布尔运算符
  11. = E 赋值运算符

程序的组织结构

任何简单或者复杂的算法 可以由顺序结构、选择结构(if语句)和循环结构(while for-in语句)组成

顺序结构

程序开始-代码1-代码2-代码3……代码N——程序结束

对象的布尔值

Python一切为对象 所有对象都有一个布尔值
获取对象的布尔值,使用内置函数bool()

#以下对象bool值均为False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
#其他对象bool值均为True

分支结构

if 条件表达式:
如果满足条件执行缩进的代码
else:
如果不满足条件执行else里面缩进的代码

#单分支结构
money=1000
s=int(input('请输入取款金额:'))
if money>=s:
    money=money-s
    print('取款成功,余额为:',money)

#双分支结构
num=int(input('请输入一个整数:'))
if num/2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

#多分支结构
score=float(input('请输入一个成绩:'))
if 90<=score<=100:
    print('A')
elif 80<=score<90:
    print('B')
elif 70<=score<80:
    print('C')
elif 60<=score<70:
    print('D')
elif 0<=score<60:
    print('E')
else:
    print('不是有效成绩')

#嵌套if的使用
answer=input('您是会员吗?y/n')
money=float(input('请输入您的购物金额:'))
if answer=='y':
    if money>=200:
        print(money*0.8)
    elif money>=100:
        print(money*0.9)
    else:
        print(money)
else:
    if money>=200:
        print(money*0.95)
    else:
        print(money)

条件表达式和pass语句

条件表达式是if……else(简写),语法结构:x if 判断条件 else y,如果判断条件的布尔值为True,条件表达式的返回值为x,否则条件表达式的返回值为y

# 从键盘中输入两个整数,判断两个整数的大小
num1=int(input('请输入第一个整数'))
num2=int(input('请输入第二个整数'))
'''if num1>=num2:
    print(num1,'大于等于',num2)
else:
    print(num1,'小于',num2)'''

print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))

'''
pass语句什么都不做,只是一个占位符,用在需要语句的地方
#使用时间:先搭建语法结构,还没好代码怎么写的时候
配套使用:
1. if 语句的条件执行体
2. for--in语句的循环体
3. 定义函数的函数体 
'''
answer=input('您是会员吗?y/n')
if answer=='y':
    pass
else:
    pass

range()函数的使用

【python】-【】,Java,python,网络,microsoft

#range()的三种创建方式
# 第一种创建方式
r=range(10) #默认从零开始,默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列 -->list是列表的意思
# 输出:[0,1,2,3,4,5,6,7,8,9]

# 第二种创建方式
r=range(1,10) #指定起始值,从1开始到10结束(不包含10)
print(list(r))
# 输出:[1,2,3,4,5,6,7,8,9]

#第三种创建方式
r=range(1,10,2) #步长为2
print(list(r))# 输出:[1,3,5,7,9]

# 判断指定的m
print(9 in r)
print(8 not in r)

while循环

【python】-【】,Java,python,网络,microsoft

sum=0
a=0
while a<5:
    sum+=a
    a+=1
print(sum)

# 1到100之间【python】-【】,Java,python,网络,microsoft
的偶数和
sum=0
a=1
while a<=100:
    if not bool(a%2):             # if a%2==0:
        sum+=a
    a+=1
print(sum)

for_in循环

【python】-【】,Java,python,网络,microsoft

for item in 'python':
    print(item)
# range()产生的整数序列,也是一个可迭代对象
for i in range(10):
    print(i)
# 如果在循环体中不需要使用到自定义变量,可将自定义变量写为“_“
for _ in range(5):
    print('人生苦短')

# 100到999之间的水仙花数
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    #print(bai,shi,ge)
    if ge**3+shi**3+bai**3==item:
        print(item)

流程控制语句break和continue

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

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

else语句

与while和for搭配使用:只要循环正常执行完,就会执行else
【python】-【】,Java,python,网络,microsoft

for item in range(3):
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起,三次密码均输入错误')

嵌套循环

for i in range(1,4):  #行表
    for j in range(1,5): 
        print('*',end='\t') #不换行输出
    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,11):
        if j%2==0:
            #break
            continue
        print(j,end='\t')
    print()

列表

列表的创建

【python】-【】,Java,python,网络,microsoft

# 列表对象
# 创建列表的第一种方式,[]
lst=['hello','world',98,'hello']
print(id(lst))
print(type(lst))
print(lst)
print(lst[0],lst[-4])
# 创建列表的第二种方式,list()
lst2=list(['hello','world',98])
print(id(lst2))
print(type(lst2))
print(lst2)

列表的特点

【python】-【】,Java,python,网络,microsoft

获取列表中单个元素

【python】-【】,Java,python,网络,microsoft

lst=['hello','world',98,'hello']
print(lst.index('hello')) #列表中有相同元素只返回列表中相同元素的的第一个元素的索引
# print(lst.index('python')) #ValueError: 'python' is not in list
# print(lst.index('hello',1,3)) #ValueError: 'hello' is not in list  1-'world' 2-98 不包括3
print(lst.index('hello',1,4))

lst=['hello','world',98,'hello','world',234]
# 获取索引为2的
print(lst[2])
# 获取索引为-3的
print(lst[-3])
# 获取索引为10的
print(lst[10]) # IndexError: list index out of range

获取列表中的多个元素——切片操作

【python】-【】,Java,python,网络,microsoft

lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1])# [20,30,40,50,60]
print(lst[1:6]) #默认步长为1 [20,30,40,50,60]
print(lst[1:6:])#默认步长为1 [20,30,40,50,60]
print(lst[1:6:2]) #步长为2 [20,40,60]
print(lst[:6:2])# [10,30,50]
print(lst[1::2])# [20,40,60,80]
print(lst[::2])# [10,30,50,70]
print(lst[::])# [10,20,30,40,50,60,70,80]
# 步长为负数
print(lst[::-1])# [80,70,60,50,40,30,20,10]
print(lst[7::-1])# [80,70,60,50,40,30,20,10]
print(lst[6:0:-2])# [70,50,30]
# 新切出来的是一个新的列表对象
print('原列表',id(lst))# 2005509464960
lst2=lst[1:6:1]
print('切的片段',id(lst2))# 2005510479424

列表元素的判断及遍历

【python】-【】,Java,python,网络,microsoft

lst=[10,20,'python','hello']
print(10 in lst) #判断
print(10 not in lst)
for item in lst: #遍历
    print(item)

列表元素的增删改操作

列表元素的增加操作

【python】-【】,Java,python,网络,microsoft

# 向列表末尾添加元素
lst=[10,20,30]
print(lst,id(lst))# 2181409792960
lst.append(100)
print(lst,id(lst))# 2181409792960

lst2=['hello','world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表末尾 [10,20,30,['hello','world']]
lst.extend(lst2) # 向列表末尾添加多个元素 [10,20,30,'hello','world']
print(lst)

lst.insert(1,90) # 在任意位置上添加一个元素,在索引为1的位置上添加一个90
print(lst)# [10,90,20,30,'hello','world']

lst3=[True,False,'hello']
lst[1:]=lst3 # 在任意位置添加N个元素,从第一个元素开始后面的元素全删除(切掉),然后再添加元素
print(lst)# [10,True,False,'hello']

列表元素的删除操作

【python】-【】,Java,python,网络,microsoft

lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素,如果有重复元素只移除第一个元素
print(lst)# [10,20,40,50,60,30]
# lst.remove(100) #ValueError: list.remove(x): x not in list

#pop()根据索引移除元素
lst.pop(1)
print(lst)# [10,40,50,60,30]
# lst.pop(5) #IndexError: pop index out of range
lst.pop() #如果不指定参数,将删除最后一个参数
print(lst)# [10,40,50,60]

# 切片操作会产生一个新的列表对象,切片相当于从列表中取数
new_lst=lst[1:3]
print('原列表',lst)# [10,40,50,60]
print('切片后列表',new_lst)# [40,50]
# 不产生新的列表对象,而是删除原列表中的内容
lst[1:3]=[]
print(lst)# [10,60]

lst.clear() #清除列表中的所有元素
print(lst)
del lst #将列表对象删除
# print(lst) # NameError: name 'lst' is not defined. Did you mean: 'list'?

列表元素的修改操作

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

列表元素的排序操作

【python】-【】,Java,python,网络,microsoft

lst=[20,40,10,98,54]
print('排序前',lst,id(lst))# [20,40,10,98,54] 1632705897408
lst.sort() #升序
print('排序后',lst,id(lst))# [10,20,40,54,98] 1632705897408
# 指定关键字参数,实现列表元素的降序排序
lst.sort(reverse=True) #降序
print(lst)# [98,54,40,20,10]
lst.sort(reverse=False) #升序
print(lst)# [10,20,40,54,98]

# 使用内置函数sorted()对列表进行排序,将产生一个新的列表
lst=[20,40,10,98,54]
new_lst=sorted(lst) #产生一个新列表 升序
print(lst)# [20,40,10,98,54]
print(new_lst)# [10,20,40,54,98]
# 指定关键字参数,实现列表元素的降序排序
desc_lst=sorted(lst,reverse=True) #降序
print(desc_lst)# [98,54,40,20,10]

列表生成式

【python】-【】,Java,python,网络,microsoft

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

字典

【python】-【】,Java,python,网络,microsoft
可变序列:能够进行增删改的序列
列表是有序序列
【python】-【】,Java,python,网络,microsoft
key是不可变序列,如str,不可变序列不可执行增删改操作

字典的创建

【python】-【】,Java,python,网络,microsoft

使用内置函数dict()是通过赋值的形式创建字典,所以左侧不加‘’,右侧加不加根据右侧的数据类型来定

# 使用花括号
scores={'张三':100,'李四':98,'王五':45}
print(scores)
# 使用内置函数
stu=dict(name='jack',age=20)
print(stu)

字典的常用操作

字典元素的获取

【python】-【】,Java,python,网络,microsoft

# 获取字典中的值,使用[]
print(scores['张三'])
# print(scores['陈六']) # KeyError: '陈六'
# 使用get()
print(scores.get('张三'))
print(scores.get('陈六')) # None
# 如果查找的key不存在,返回某个默认值
print(scores.get('马七',99)) # 99是在查找‘马七’所对的value不存在时,提供的一个默认值

字典元素的增删改操作

【python】-【】,Java,python,网络,microsoft

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

获取字典视图

【python】-【】,Java,python,网络,microsoft

scores={'张三':100,'李四':98,'王五':45}
# 获取所有的key
keys=scores.keys()
print(keys)# dict_keys(['张三','李四','王五'])
print(type(keys))# dict_keys
# scores.keys()得到的数据的类型是dict_keys,我们可以将所有的key组成的视图转成列表
print(list(keys))# ['张三','李四','王五']

# 获取所有的value
values=scores.values()
print(values)# dict_values([100,98,45])
print(type(values))# dict_values
print(list(values))# [100,98,45]

#获取所有的key-value对
items=scores.items()
print(items)# dict_items([('张三':100),('李四':98),('王五':45)])
print(list(items)) # 转换之后的列表元素是由元组组成:[('张三':100),('李四':98),('王五':45)]

字典元素的遍历

【python】-【】,Java,python,网络,microsoft
item是遍历出来的键的名称,score是要遍历的字典的名称

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

字典的特点

【python】-【】,Java,python,网络,microsoft

d={'name':'张三','name':'李四'} # key不允许重复,重复的key会覆盖原来的值
print(d)# {'name':'李四'}
d={'name':'张三','nikename':'张三'} # value允许重复
print(d)# {'name':'李四','name':'张三','nikename':'张三'}

字典生成式

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
# 遍历两个list中的值,分别存放在item,price中,item,price是要放在字典中的,所以最外层用了{},里面写作item:price,如果想要items大写,那么使用item.upper()
d={item.upper():price   for item,price in zip(items,prices)}
print(d)# 当两个list的个数不一致时,以短的那个为准
lst=zip(items,prices)
print(list(lst))

元组

【python】-【】,Java,python,网络,microsoft

'''可变序列 列表,字典:可以进行增删改,即列表/字典进行增删改后,列表/字典在内存中的地址不变'''
lst=[10,20,45]
print(id(lst))# 1808459865024
lst.append(200)
print(id(lst))# 1808459865024
'''不可变序列 字符串,元组:不可以进行增删改,
即不可变序列进行增删改并非在原序列上操作,而是在内存中新开辟一个序列,所以不可变序列进行增删改后在内存中的地址会改变'''
s='hello'
print(id(s))# 2753280992112
s=s+'world'
print(id(s))# 2753284295600
print(s)

元组的创建方式

【python】-【】,Java,python,网络,microsoft

# 第一种,用()
t=('Python','world',98)
print(t)# ('Python','world',98)
print(type(t))# tuple

t2='Python','world',98 # 省略了小括号
print(t2)# ('Python','world',98)
print(type(t2))# tuple

t=('Python',) # 只包含一个元组的元素需要使用逗号和小括号,不然为str类型(此处)
print(t)# ('Python')
print(type(t))# tuple

# 第二种创建方式,内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)# ('Python','world',98)
print(type(t1))# tuple

# 空列表
lst=[]
lst1=list()
# 空字典
d={}
d1=dict()
# 空元组
t=()
t1=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t1)

为什么要将元组设计成不可变序列

【python】-【】,Java,python,网络,microsoft
一旦创建了不可变类型的对象,对象内的所有数据就不能再被修改了,这就避免了由于修改数据而导致的错误。此外对于不可变类型的对象,在多任务环境下,同时操作对象时不需要加锁
【python】-【】,Java,python,网络,microsoft
元组中保存的数据为(10,[20,30],9),10和9都是不可变对象,不能引用其他值,如果我想把[20,30]位置的数据换成100,这也是不可以的,因为[20,30]是可变对象,可变对象的引用不可以改变,只能在[20,30]后面追加100,元组中原本指向[20,30]的内存地址不变

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

元组的遍历

【python】-【】,Java,python,网络,microsoft

#元组的遍历
t=('Python','world',98)
#1.索引
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) #IndexError: tuple index out of range
#2.遍历
for item in t:
    print(item)

集合

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

# 集合的创建方式
# 1.{}
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)# {2,3,4,5,6,7}

#2.set()
s1=set(range(6))
print(s1,type(s1))# {0,1,2,3,4,5} set
# 通过set()将列表中的元素转成集合
s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))# {1,2,3,5,6} set
# 通过set()将元组中的元素转成集合
s3=set((1,2,4,4,5,65)) #集合中的元素是无序的
print(s3,type(s3))# {1,2,4,5,65} set
# 通过set()将字符串中的元素转成集合
s4=set('python')
print(s4,type(s4))# {'n','h','p','y','t','y'} set
# 通过set()将字典中的元素转成集合
s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))# {34,66,4,55,12,44} set

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

集合的相关操作

【python】-【】,Java,python,网络,microsoft

#集合的相关操作
#判断操作
s={10,2,0,30,40,50}
print(10 in s)# true
print(100 in s)# false
print(0 not in s)# false
#新增操作
s.add(80) #一次添加一个
print(s)# {10,80,2,30,0,40,50},无序的
s.update({200,300,4000}) #一次至少添加一个元素,把一个集合添加到指定集合中
print(s)# {200,300,10,80,2,30,0,40,50,4000},无序的
# 也可以以列表和元组的形式批量往里添加数据
s.update([100,99,6])
s.update((78,56,48))
print(s)# {78,200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}

#删除操作
s.remove(10)
print(s)# {78,200,56,300,100,80,48,2,6,30,0,40,99,50,4000}
# s.remove(500) #KeyError: 500
# print(s)
# 如果集合中有500则删除,没有也不报错
# s.discard(500) #没有,不报错
# print(s)
s.pop() #只能删除第一个,且不能添加参数
print(s)# {200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}
s.clear() #清空集合
print(s)# set()

集合间的关系

【python】-【】,Java,python,网络,microsoft

# 两个集合是否相等(元素相同,就相等)
s={10,20,30,40}
s2={20,30,40,10}
print(s==s2) #T
print(s!=s2) #F
#子集和超集
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #T s2的所有数据都在s1中,所以s2是s1的子集
print(s3.issubset(s1)) #F 
print(s1.issuperset(s2)) #T s2的所有数据都在s1中,所以s1是s2的超集
print(s1.issuperset(s3)) #F
#交集
print(s2.isdisjoint(s3)) #F - 有交集
s4={100,200,300}
print(s2.isdisjoint(s4)) #T - 没有交集

集合的数据操作

【python】-【】,Java,python,网络,microsoft

# 集合的数学操作
#(1)交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))# {40,30,20}
print(s1&s2)# &与intersection等价,都是求交集操作,输出:{40,30,20}

#(2)并集
print(s1.union(s2))# {40,30,20,10,50,60}
print(s1|s2)# |与union等价,都是求并集操作,输出:{40,30,20,10,50,60}

#(3)差集
print(s1.difference(s2)) #s1有s2没有,输出:[10]
print(s1-s2)# -与difference等价,都是求差集操作,输出:[10]
print(s2.difference(s1))# s2有s1没有,输出:[50,60]

#(4)对称差集
print(s1.symmetric_difference(s2)) #集合交集以外的元素,输出:[10,50,60]
print(s1^s2)# ^与symmetric_difference等价,都是求对称差集操作,输出:[10,50,60]

集合生成式

【python】-【】,Java,python,网络,microsoft

s={i*i for i in range(10)}
print(s)

总结

【python】-【】,Java,python,网络,microsoft

字符串

字符串的创建和驻留机制

【python】-【】,Java,python,网络,microsoft

#字符串
#字符串的定义及驻留机制
a='python'
b="python"
c='''python'''
print(a,id(a))# python 1874508798960
print(b,id(b))# python 1874508798960
print(c,id(c))# python 1874508798960

驻留机制:仅保存一份相同且不可变的字符串的方式
【python】-【】,Java,python,网络,microsoft
交互模式:cmd下执行python即可进入交互模式
符合标识符的字符串:含有字母数字下划线的字符串
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
b是在程序编译时完成了拼接,c是在程序运行时使用join完成拼接,a is c为false
可以使用sys实现强制驻留
【python】-【】,Java,python,网络,microsoft

字符串的常用操作

字符串的查询操作

【python】-【】,Java,python,网络,microsoft

#字符串查询操作
s='hello,hello'
print(s.index('lo')) #第一次出现的位置,输出:3
print(s.find('lo'))#第一次出现的位置,输出:9
print(s.rindex('lo')) #最后一次出现的位置
print(s.rfind('lo'))#第一次出现的位置,输出:9

# print(s.index('k')) #ValueError: substring not found 不存在
print(s.find('k')) #-1 不存在

字符串的大小写转换

【python】-【】,Java,python,网络,microsoft

#字符串的大小写转换操作
s='HelloWorld,wa'
print(s.upper(),id(s.upper())) #全转成大写会产生一个新的字符串对象,输出:HRLLOWORLD,WA 2133868981488
print(s,id(s))#helloworld,wa 2134125876016
print(s.lower()) #全转成小写,如果原来的字符串就是小写的,在执行了lower()后依旧会产生一个新的字符串对象,二者的id()依旧不一样
print(s.swapcase()) #大转小,小转大
print(s.capitalize()) #第一个字符大写,其余小写
print(s.title()) #每个单词首字母大写,其余小写

字符串内容对齐操作

【python】-【】,Java,python,网络,microsoft

#字符串内容对齐操作
s='hello,Python'
#居中对齐
print(s.center(20,'*')) #****hello,Python****
#左对齐
print(s.ljust(20,'*')) #hello,Python********
print(s.ljust(10))#hello,Python
print(s.ljust(20))#hello,Python        
#右对齐
print(s.rjust(20,'*'))#********hello,Python
print(s.rjust(20))#        hello,Python
print(s.rjust(10))#hello,Python
#右对齐,左边用0填充
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910

字符串的劈分操作

【python】-【】,Java,python,网络,microsoft

#字符串的劈分操作
s='hello world Python'
print(s.split())# 默认以空格拆分,输出:['hello','world','Python']
s1='hello|world|Python'
print(s1.split())# ['hello world Python']
print(s1.split(sep='|'))# 指定分隔符,['hello','world','Python']
print(s1.split(sep='|',maxsplit=1))#['hello','world|Python'] 
#从右侧分
print(s1.rsplit(sep='|',maxsplit=1))# ['hello|world','Python']

字符串的判断操作

【python】-【】,Java,python,网络,microsoft

#字符串判断的相关方法
#合法标识符
s='hello,python'
print(s.isidentifier()) #F
print('hello'.isidentifier()) #T
print('张三_123'.isidentifier()) #T
#空白字符
print('\t'.isspace()) #T
print(' '.isspace()) #T
#字母
print('abc'.isalpha()) #T
print('张三'.isalpha()) #T
print('张三1'.isalpha()) #F
#十进制数字
print('123'.isdecimal()) #T
print('123四'.isdecimal()) #F
print('ⅡⅢⅣ'.isdecimal()) #F
#数字
print('123'.isnumeric()) #T
print('123四'.isnumeric()) #T
print('ⅡⅢⅣ'.isnumeric()) #T
print('壹贰叁'.isnumeric()) #T
#字母和数字
print('abc1'.isalnum()) #T
print('张三123'.isalnum()) #T
print('abc!'.isalnum()) #F

字符串的其他操作

【python】-【】,Java,python,网络,microsoft

#字符串的其他操作
#字符串的替换
s='hello,Python'
print(s.replace('Python','Java'))# 用Java替换python,输出:hello,Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2)) #第三个次数指定替换次数,输出hello,Java,Java,Python
#字符串的合并
# 连接数组元素
lst=['hello','java','python']
print('|'.join(lst))# hello|java|python
print(''.join(lst))# hellojavapython
# 连接元组元素
t=('hello','java','python')
print(''.join(t))# hellojavapython
# 连接字符串的元素
print('*'.join('python'))# p*y*t*h*o*n

字符串的比较操作

【python】-【】,Java,python,网络,microsoft

#字符串的比较操作
print('apple'>'app') #T
print('apple'>'banana') #F, 97>98 F
print(ord('a'),ord('b')) #原始值这里是字母的ascll码
print(ord('刘'))
print(chr(97),chr(98))# 获取ascii码为97的值,即a。chr()和ord()互为相反的两个方法
print(chr(21016))

'''==和is的区别
==比较的是value
is 比较的是 id'''
a=b='python'
c='python'
print(a==b) #T
print(b==c) #T
print(a is b) #T
print(a is c) #T
print(id(a)) #2383540093936
print(id(b)) #2383540093936
print(id(c)) #2383540093936

字符串的切片操作

【python】-【】,Java,python,网络,microsoft

#字符串的切片操作
s='hello,python'
print(s[:5]) #没有指定起始位置,从0开始,输出:hello
print(s[6:]) #没有指定结束位置,所以切到字符串最后一个元素,输出:python
s1='!'
newstr=s[:5]+s1+s[6:]
print(newstr) # hello!python
print(id(s))# 1990114866608
print(id(s[:5]))# 1990110831472
print(id(s[6:]))# 1990110735152
print(id(s1))# 1989860883760
print(id(newstr))# 1990110735216

print(s[1:5:1]) #完整写法 从一切到四,步长为一,输出:ello
print(s[::2]) #从0开始切到最后,输出:hlopto
print(s[::-1]) #从最后一个元素开始往前到第一个元素,步长为1,输出:nohtyp,olleh
print(s[-6::1])#从索引为-6的开始,到字符串的最后一个元素,步长为1,输出:python

格式化字符串

【python】-【】,Java,python,网络,microsoft
格式化字符串:按一定格式输出的字符串
【python】-【】,Java,python,网络,microsoft

#格式化字符串
# % 占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
# {},0代表取format的第一个参数,所有用到0的地方都使用这个参数的值
print('我叫{0},今年{1}岁,我真的叫{0}'.format(name,age))
# f-string,前面加f代表格式化字符串
print(f'我叫{name},今年{age}岁')

#宽度和精度
print('%10d' % 99) #10个宽度,输出:          99
print('%.3f' % 3.1415926) #.3表示小数点后三位,输出:3.142
print('%10.3f' % 3.1415926) #宽度为10,保留三位小数,输出:          3.142
print('hellohello')
# 下面的0均指format第一个参数
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数,输出:3.14
print('{0:.3f}'.format(3.1415926)) #.3f表示3位小数,输出:3.142
print('{0:10.3f}'.format(3.1415926)) #宽度是10位,3位是小数,输出

字符串的编码转换

【python】-【】,Java,python,网络,microsoft

#字符串的编码转换
s='天涯共此时'
#编码
print(s.encode(encoding='GBK')) #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'))

函数

函数的定义与调用

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

#函数的定义和调用
def calc(a,b):  #a,b为形式参数,形参位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)  #10,20称为实际参数的值,实参的位置是函数的调用处
print(result)

#函数参数的传递
res=calc(b=10,a=20)  #=左边的变量名称为 关键字参数
print(res)

【python】-【】,Java,python,网络,microsoft

#函数参数传递的内存分析
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)
print('-------')
fun(n1,n2)
print('n1=',n1)
print('n2=',n2)

'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会形象实参的值 arg1修改为100,不会影响n1的值
如果是可变对象,在函数体的修改会影响到实参的值 arg2的修改,append(10),会影响到n2的值'''

函数的返回值

【python】-【】,Java,python,网络,microsoft

#函数的返回值
def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i % 2: #bool(0)=False
            odd.append(i)
        else:
            even.append(i)
    return odd,even

print(fun([10,29,34,23,44,53,55]))

'''
(1)如果函数没有返回值【函数执行完毕后,不需要给调用处提供数据】 return可以省略
(2)如果函数有一个返回值,直接返回原类型
(3)如果函数有多个返回值,返回结果为元组
'''
def fun1():
    print('hello')
    #return

fun1()

def fun2():
    return 'hello'

res=fun2()
print(res)

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

print(fun3())
'''函数在定义时,是否需要返回值,视情况而定'''

函数参数定义

【python】-【】,Java,python,网络,microsoft

#默认值参数
def fun(a,b=10):  #b为默认值
    print(a,b)

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

查看print的源码发现:
【python】-【】,Java,python,网络,microsoft
这个end就是默认值参数,默认换行,如果你不想换行,可以给end传其他值:

print('hello',end='\t')
print('world')
# 输出:hello world

【python】-【】,Java,python,网络,microsoft

#函数的参数定义
def fun(*args):  #函数定义时,个数可变的位置参数
    print(args)

fun(10)
fun(10,20,30)

def fun1(**args): #个数可变的关键字参数
    print(args)

fun1(a=10)
fun1(a=20,b=20,c=40)

''' def fun2(*args,*a):
       pass
    报错,个数可变的位置参数,只能是一个
    def fun2(*args,*a):
        pass
    报错,个数可变的关键字参数,只能是一个'''

def fun2(*args1,**args2):
    pass

''' def fun3(**args1,*args2):
        pass
在一个函数定义的过程中,既有个数可变的关键字参数,也有个数可变的位置形参,要求个数可变的位置形参,放在个数可变的关键字形参之前'''

【python】-【】,Java,python,网络,microsoft

#函数参数总结
def fun(a,b,c):  # a,b,c在函数的定义处,所以是形式参数
    print('a=',a)
    print('b=',b)
    print('c=',c)

#函数的调用
fun(10,20,30)  #函数调用时的参数传递,称为位置传参
'''
输出:
a=10
b=20
c=30
'''
lst=[11,22,33]
fun(*lst)  #函数调用时,将列表的每个元素都转换为位置实参传入
'''
输出:
a=11
b=22
c=33
'''
print('--------')
fun(a=100,c=300,b=200)  #关键字实参
'''
输出:
a=100
b=200
c=300
'''
dic={"a":111,'b':222,'c':333}
fun(**dic)  #在函数调用时,将字典的键值对都转换为关键字实参传入
'''
输出:
a=111
b=222
c=333
'''
def fun4(a,b,*,c,d):  #从*之后的参数,在函数调用时,只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#fun4(10,20,30,40) #位置实参传递
fun4(a=10,b=20,c=10,d=40) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个位置实参传递,后两个关键字实参传递

'''函数定义时形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args1):
    pass
def fun7(a,b=10,*args,**args1):
    pass

变量的作用域

【python】-【】,Java,python,网络,microsoft

#变量的作用域
def fun(a,b):
    c=a+b  #c,就称为局部变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量 
    print(c)

name='刘'   #全局变量
print(name)
def fun1():
    print(name)
fun1()

def fun3():
    global age  #函数内部定义的变量,局部变量,其用global声明,这个变量变为全局变量
    age=20
    print(age)
fun3()
print(age)

递归函数

【python】-【】,Java,python,网络,microsoft

#递归函数
def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(9))

#斐波那契数列
def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

print(fib(6))

for i in range(1,7):
    print(fib(i))

bug

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

#bug的常见类型
#1.
age=input('请输入你的年龄:')
print(type(age))
# if age>=18:  #TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age)>=18:
    print('你是成年人了')

#2.
# while i<10:
#     print(i)
i=0
while i<10:
    print(i)
    i+=1

#3.
for i in range(3):
    uname=input('请输入用户名:')
    pwd=input('请输入密码:')
    # if uname='admin' and pwd='admin':
    if uname=='admin' and pwd=='admin':
        print('登陆成功!')
        break
    # else
    else:
        print('输入有误')
else:
    print('对不起,三次均输入错误')

#4.索引越界问题IndexError
lst=[11,22,33,44]
# print(lst[4])  #list index out of range
print(lst[3])

#5.append()方法的使用不熟练
lst=[]
# lst=append('A','B','C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)

#被动掉坑问题
''' n1=int(input('请输入一个整数:'))
    n2=int(input('请输入另一个整数:'))
    result=n1/n2
    print('结果为:',result)'''

python的异常机制:try…exception

【python】-【】,Java,python,网络,microsoft
当存在多个异常需要捕获时,可以采用多个except结构:
【python】-【】,Java,python,网络,microsoft

#try...except结构
try:
    n1=int(input('请输入一个整数:'))
    n2=int(input('请输入另一个整数:'))
    result=n1/n2
    print('结果为:',result)
except ZeroDivisionError:
    print('对不起,除数不允许为零')
except ValueError:
    print('不能将字符转换为数字')
print('程序结束')

【python】-【】,Java,python,网络,microsoft

#try...except...else结构
try:
    n1=int(input('请输入一个整数:'))
    n2=int(input('请输入另一个整数:'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为:',result)

【python】-【】,Java,python,网络,microsoft

#try...except...else...finally结构
try:
    n1=int(input('请输入一个整数:'))
    n2=int(input('请输入另一个整数:'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为:',result)
finally:
    print('谢谢您的使用')
print('程序结束')

python中常见的异常类型

【python】-【】,Java,python,网络,microsoft

#常见的异常类型
# print(10/0)  #ZeroDivisionError

lst=[11,22,33,44]
# print(lst[4])  #IndexError

dic={'name':'张三','age':20}
# print(dic['gender'])  #KeyError

# print(num)  #NameError

# int a=20  #SyntaxError

#a=int('hello')  #ValueError

traceback模块的使用

【python】-【】,Java,python,网络,microsoft

#traceback模块的使用
import traceback
try:
    print('--------------')
    print(1/0)
except:
    traceback.print_exc()

对象

python中一切皆对象
【python】-【】,Java,python,网络,microsoft

类的创建

【python】-【】,Java,python,网络,microsoft
实例方法写不写self都会有个self在(不写程序白送你一个),静态方法中不允许写self,类方法中需要传入cls
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

#定义python中的类
class Student:  #Student为类的名称(类名)由一个或多个单词组成,每个单词首字母大写,其余小写
    native_place='吉林'  #直接写在类里的变量,成为类属性
    def __init__(self,name,age):
        self.name=name  #self.name 称为实例属性,进行了一个赋值操作,将局部变量的name的值赋给实体属性/实例变量
        self.age=age
    #实例方法
    def eat(self):
        print(self.name+'在吃饭')
    #静态方法
    @staticmethod
    def sm():
        print('静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('类方法')
#在类之外定义的称为函数,再类之内定义的称为方法
def drink():
    print('喝水')

#创建Student类的对象
stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))# 1421362237888
print(type(stu1))# <class '__main__.Student'>
print(stu1)# <__main__.Student object at 0x0000014AEFCA91C0>
# 1421362237888的十六进制为0x0000014AEFCA91C0
# 实例对象会有一个类指针指向类对象
print(id(Student))# 2218905389200
print(type(Student))# <class ‘type’>
print(Student)# <class '__main__.Student'>
# 下面两行都可以调用类的实例方法:实例对象.实例方法 或者 类对象.实例方法(实例对象)
stu1.eat()  #对象名.方法名()
Student.eat(stu1)  #类名.方法名(类的对象)-->实际上就是方法定义处的self
print(stu1.name)
print(stu1.age)

#类属性的使用方式
#print(Student.native_place)
print(stu1.native_place)# 吉林
print(stu2.native_place)# 吉林
Student.native_place='天津'
print(stu1.native_place)# 天津
print(stu2.native_place)# 天津
#类方法的使用方式
Student.cm()
#静态方法的使用方式
Student.sm()

#动态绑定属性和方法
stu2.gender='女'  #动态绑定性别属性
# print(stu1.name,stu1.age,stu1.gender)  #AttributeError: 'Student' object has no attribute 'gender'
print(stu2.name,stu2.age,stu2.gender)
stu1.eat()
stu2.eat()
def show():
    print('定义在类之外的,称为函数')
stu1.show=show  #动态绑定方法
stu1.show()
# stu2.show()  #AttributeError: 'Student' object has no attribute 'show'

面向对象的三大特征

封装

【python】-【】,Java,python,网络,microsoft

#封装
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)  #AttributeError: 'Student' object has no attribute '__age'
# print(dir(stu))  #获取对象所有的属性和方法
print(stu._Student__age)  #在类的外部可以通过 _Student__age 进行访问,输出:20

继承

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
定义类时,括号里写父类,如上述Person的父类是object,Student的父类是Person。python支持多继承,比如a继承object,b继承object,c可以同时继承a,b:class c(a,b)
【python】-【】,Java,python,网络,microsoft

#继承
class 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,score):
        super().__init__(name, age)# 在子类的init方法中使用super().__init__调用父类的初始化方法进行赋值
        self.score=score# 然后再对自己内部的属性进行初始化
    def info(self):  #方法的重写,重写父类的info()
        super().info()# 如果还想用到父类的info()的方法体,使用super().info()调用
        print(self.score)
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('Jack',20,'1001')
stu.info()
tea=Teacher('Tom',40,20)
tea.info()
object类

【python】-【】,Java,python,网络,microsoft

#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('jack',20)
print(dir(stu))
print(stu)# 默认会调用__str__(self)方法,如果没有覆写,会输出实例对象的内存地址【python】-【】,Java,python,网络,microsoft

print(type(stu))

多态

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft
像Java这种静态语言实现多态需要具备三个必要条件:继承、方法重写、父类指向子类对象,但是python是动态语言,他只关心你有没有这个方法,其余都不管

#多态
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())

特殊方法和特殊属性

【python】-【】,Java,python,网络,microsoft

#特殊属性
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建C类对象
x=C('jack',20)  #x是C类型的一个实例对象
print(x.__dict__)  #查看实例对象的属性字典
print(C.__dict__)# 查看类对象的属性字典
print(x.__class__)  #输出对象所属的类型 <class '__main__.C'>
print(C.__bases__)  #C类的父类类型的元组:(<class '__main__.A'>,<class '__main__.B'>)
print(C.__base__)  #类的基类,C继承A和B,所以输出<class '__main__.A'>,如果C继承B和A,则输出<class '__main__.B'>,C多继承时,谁在前就输出谁
print(C.__mro__)  #类的层次结构:(<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class 'object'>)
print(A.__subclasses__())  #子类的列表:[<class '__main__.C'>,<class '__main__.D'>]

#类的特殊方法
a=20
b=100
c=a+b  #两个整数类型的对象的相加操作
d=a.__add__(b)# 两个整数类型的对象的相加操作,底层调用的是__add__()进行相加
print(c)# 120
print(d)# 120

class Student:
    def __init__(self,name):
        self.name=name
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2  #报错:Student类型不能进行相加,但是我想要相加怎么办呢?给Student类定义一个__add__()方法,如下所示
print(len(stu1))# 同理,如果我想输出长度,也会报错,但是我又想输出怎么办呢?给Student类定义一个__len__()方法,如下所示

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  #实现两个对象的加法运算
print(s)# 张三李四
s=stu1.__add__(stu2)
print(s)# 张三李四

lst=[11,22,33,44]
print(len(lst))# 4,调用len(lst)时底层执行了lst.__len__()
print(lst.__len__())# 4
print(len(stu1))# 2

__new__和__init__创建对象的过程

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)))

'''
程序的执行结果:
object这个类对象的id为:140717796113232
Person这个类对象的id为:2690679899360
__new__被调用执行了,cls的id值为2690679899360
创建的对象的id为:2690436007104
__init__被调用了,self的id值为:2690436007104
p1这个Person类的实例对象的id:2690436007104
'''

类的浅拷贝与深拷贝

【python】-【】,Java,python,网络,microsoft

#类的浅拷贝与深拷贝
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)# <__main__.CPU object at 0x000002B4D38D8490>
print(cpu2)# <__main__.CPU object at 0x000002B4D38D8490>
#(2)类的浅拷贝
disk=Disk()  #创建一个硬盘类的对象
computer=Computer(cpu1,disk)  #创建一个计算机类的对象

#浅拷贝
import copy
print(disk)# <__main__.Disk object at 0x000001782E443490>
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001781F3284C0> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>
print(computer2,computer2.cpu,computer2.disk)# <__main__.Computer object at 0x000001781F328190> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>

#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001813E8284C0> <__main__.CPU object at 0x000001813E738490> <__main__.Disk object at 0x000001814D913490>
print(computer3,computer3.cpu,computer3.disk)# <__main__.Computer object at 0x000001813E8281F0> <__main__.CPU object at 0x000001814D943A30> <__main__.Disk object at 0x000001814EA626A0>

模块

【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(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))

假如我现在自定义了一个模块calc.py,我想在demo5.py模块中导入他,如果我直接写import calc会报错,需要将demo5.py所在包设为source root
【python】-【】,Java,python,网络,microsoft

以主程序方式运行

【python】-【】,Java,python,网络,microsoft
假如定义了一个calc2.py,内容如下:

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

print(add(10,20))

然后在demo7.py中引入了他,并执行了print(calc2.add(100,200)),会打印输出30 300,因为他先执行了calc2.py的打印,如果我们只想输出300,不让他执行calc2.py的打印输出,可以这样:

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

if __name__ == '__main__':  #只有在这个模块运行时,才执行下述代码
    print(add(10,20))

python中的包

【python】-【】,Java,python,网络,microsoft
一个python程序中有无数个包,每个包中有无数个模块,每个模块中又有无数的类、方法、语句。python中创建包:
【python】-【】,Java,python,网络,microsoft
在demo8.py中导入包中的模块
【python】-【】,Java,python,网络,microsoft
【python】-【】,Java,python,网络,microsoft

python中常用的内容模块

【python】-【】,Java,python,网络,microsoft

import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))# 28:24占了28个字节
print(sys.getsizeof(45))# 28
print(sys.getsizeof(True))# 28
print(sys.getsizeof(False))# 24
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

第三方模块的安装及使用

【python】-【】,Java,python,网络,microsoft

#第三方模块的安装  pip install 模块名
import schedule
import time

def job():
    print('hh')

schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

文件

编码格式

【python】-【】,Java,python,网络,microsoft

在操作中文文本文件时,经常出现乱码情况,

文件的读取原理

【python】-【】,Java,python,网络,microsoft
解释器调用操作系统的资源读取.py文件操作磁盘上的文件(对文件进行读写操作)
【python】-【】,Java,python,网络,microsoft
a.txt的内容为:

中国
美丽

#读
file=open('a.txt','r')
print(file.readlines())# ['中国\n','美丽'],输出一个数组
file.close()

【python】-【】,Java,python,网络,microsoft
向b.txt文件写入hello

# 写
file=open('b.txt','w')# 如果没有b.txt文件则创建,如果有b.txt文件,因为第二个参数传的w,所以会清除文件原有的内容,重新写入新内容
file.write('hello')
file.close()
#追加
file=open('b.txt','a')# 如果没有b.txt文件则创建,如果有b.txt文件,因为第二个参数传的a,所以会在原有内容上追加新内容
file.write('hello')
file.close()
#复制图片
src_file=open('logo.png','rb')
target_file=open('copylogo.png','wb')
target_file.write(src_file.read())# 边读边写
target_file.close()
src_file.close()

文件对象的常用方法

【python】-【】,Java,python,网络,microsoft

#读
file=open('a.txt','r')
print(file.read(5))  #读取size个字节或字符
print(file.readline())  #读取一行内容,输出:中国
print(file.readlines())  #把文本文件中的每一行都作为独立的字符对象,并将这些对象放入列表返回。输出:['中国\n','美丽']
#写
file=open('c.txt','a')
# file.write('hello')
lst=['java','go','python']
file.writelines(lst)# hellojavagopython
file.close()
#移动文件指针
file=open('c.txt','r')
file.seek(2)  #将文件移动到新的位置,一个汉字占2字节,这里写1会报错,写2会从国开始输出
print(file.read())
'''
国
美丽
''' 
print(file.tell())  #返回指针当前所处位置。如果文件写完了,file.tell()返回文件长度
file.close()

file=open('d.txt','a')
file.write('hello')
file.flush()  #把缓冲区的内容写入文件,但不关闭文件
file.write('world')
file.close()

with语句

【python】-【】,Java,python,网络,microsoft

#with语句(上下文管理器)
with open('a.txt','r') as file:# 打开a.txt文件,为打开的这个文件起别名:file,file就是上下文管理器
    print(file.read())
#不用手动关闭!

open('a.txt','r')称为上下文表达式,他的执行结果file是一个上下文管理器

上下文管理器:一个类对象实现了__enter__()__exit__(),那么该类对象遵守上下文管理协议,该类的实例对象就称为上下文管理器
【python】-【】,Java,python,网络,microsoft
上述MyContentMgr类就是遵守上下文管理协议,他的实例对象MyContentMgr()就被称为上下文管理器
【python】-【】,Java,python,网络,microsoft
先执行__enter__()方法,再执行with语句体,然后退出上下文管理器,执行__exit__()方法。如果在执行with语句体的时候出现了异常,也会调用__exit__()方法,说明在上下文管理器中,无论是否有异常都会调用__enter__()__exit__()方法

利用with语句实现前述图片的复制:

with open('logo.png','rb') as src_file
	with open('copylogo.png','wb') as target_file
		target_file.write(src_file.read())# 边读边写

os模块的常用函数

【python】-【】,Java,python,网络,microsoft

#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')# 打开系统中的记事本(应用程序)
os.system('calc.exe')# 打开系统中的计算器(应用程序)
#直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')

【python】-【】,Java,python,网络,microsoft

import os
print(os.getcwd())  #返回当前的工作目录(绝对路径)
lst=os.listdir('python')  #返回指定路径下的文件和目录信息,这里参数要写相对路径
print(lst)
os.makedirs('TXT/1.txt')  #创建多级目录
os.mkdir('TXT/0.txt')  #创建目录
os.rmdir('TXT')  #删除目录
os.removedirs('TXT/1.txt')  #删除多级目录
os.chdir('C:\\')  #改变工作路径
print(os.getcwd())

path模块的常用方法

【python】-【】,Java,python,网络,microsoft文章来源地址https://www.toymoban.com/news/detail-646998.html

#os.path模块
import os.path
print(os.path.abspath('1.py'))  #获取文件的绝对路径
print(os.path.exists('1.py'),os.path.exists('2.py'))  #判断文件是否存在T/F
print(os.path.join('C:\\download','1.py'))  #目录和文件拼接操作,输出:C:\\download\\1.py
print(os.path.split('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #拆分路径和文件,输出:('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python','helloworld.py')
print(os.path.splitext('helloworld.py'))  #拆分文件和后缀名,输出:('helloworld','.py')
print(os.path.basename('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取文件名,输出:helloworld.py
print(os.path.dirname('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取目录名,输出:C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python
print(os.path.isdir('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python'))  #判断是否是路径(目录)

#获取当前目录下的.txt文件
import os
path=os.getcwd()# 获取当前目录
lst=os.listdir(path)# 获取路径下的所有文件
for filename in lst:
    if filename.endswith('.txt'):# 如果文件名以.txt结尾
        print(filename)

#
import os
path=os.getcwd()
lst_files=os.walk(path)  #遍历目录下的所有文件夹及其子文件
for dirpath,dirname,filename in lst_files:
    # print(dirpath)# 当前路径
    # print(dirname)# 文件夹
    # print(filename)# 文件
    for dir in dirname:
        print(os.path.join(dirpath,dir))
    for file in filename:
        print(os.path.join(dirpath,file))

到了这里,关于【python】-【】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 华为OD机试 - 5G网络建设(Java & JS & Python & C)

    现需要在某城市进行5G网络建设,已经选取N个地点设置5G基站,编号固定为1到N,接下来需要各个基站之间使用光纤进行连接以确保基站能互联互通,不同基站之间假设光纤的成本各不相同,且有些节点之间已经存在光纤相连。 请你设计算法,计算出能联通这些基站的最小成

    2024年02月03日
    浏览(13)
  • 🔥🔥Java开发者的Python快速进修指南:网络编程及并发编程

    今天我们将对网络编程和多线程技术进行讲解,这两者的原理大家都已经了解了,因此我们主要关注的是它们的写法区别。虽然这些区别并不是非常明显,但我们之所以将网络编程和多线程一起讲解,是因为在学习Java的socket知识时,我们通常会将它们结合使用,以实现服务器

    2024年02月05日
    浏览(21)
  • 网络正常,显示无Internet,Microsoft Store需要联网、无法加载页面

    完美解决无Internet但能正常上网的问题 - 哔哩哔哩 (转载)最近也遇到同样的问题,试过网上的几乎所有方法,例如禁用复用网卡、网络重置、禁用复用服务,也用了用修改注册表下HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesNlaSvcParametersInternet下的EnableActiveProbing项的办法,均

    2024年02月06日
    浏览(41)
  • 【WIN问题】微软Microsoft onenote/store 无法连接网络无法同步解决

    将近1个月没有使用PC端的微软笔记,手机app正常使用。登录PC端记录笔记后, Ctrl + s 保存时 OneNote 提示:无法同步,网上看了很多博客推荐的方法,尝试无果! 后面发现 Microsoft store 也不能登录(无法加载页面,错误代码: 0x80131500 )!如果你也遇到类似的问题,可以尝试以

    2024年02月16日
    浏览(36)
  • 【免费题库】华为OD机试 - 5G网络建设(Java & JS & Python & C & C++)

    哈喽,本题库完全免费,收费是为了防止被爬,大家订阅专栏后可以私信联系退款。感谢支持 现需要在某城市进行5G网络建设,已经选取N个地点设置5G基站,编号固定为1到N,接下来需要各个基站之间使用光纤进行连接以确保基站能互联互通,不同基站之间假设光纤的成本各

    2024年04月11日
    浏览(15)
  • Microsoft账户打不开登录界面、无法登录,但网络可正常上网,解决方法

    自己的情况: 实际上浏览器是可以正常上网的,不过windows网络那里显示“无网络连接”,且office等微软账号登录不上,登录界面都无法正常显示, 提示“没有网络”或类似的网络问题 。不是提示“发生了错误” 尝试了如下数遍,都不行: 参考自:https://www.zhihu.com/question

    2024年02月04日
    浏览(59)
  • Microsoft首席信息安全官CISO研讨会白皮书:网络安全简介(01)

    Microsoft Cybersecurity Briefing 01 2022年9月22日微软举行了信息安全官(CISO)研讨会 “Security is our top priority and we are committed to working with others across the industry to protect our customers.” Satya Nadella Chief Executive Officer, Microsoft Corporation “安全是我们的首要任务,我们致力于与他人合作,保护

    2024年02月04日
    浏览(38)
  • Java使用Microsoft Entra微软 SSO 认证接入

    Microsoft Entra ID 是基于云的标识和访问管理服务,可帮助员工访问外部资源。 示例资源包括 Microsoft 365、Azure 门户以及成千上万的其他 SaaS 应用程序。 Microsoft Entra ID 还可帮助他们访问你的企业 Intranet 上的应用等内部资源,以及任何为你自己的组织开发的云应用。 若要了解如

    2024年02月03日
    浏览(15)
  • Microsoft正在将Python引入Excel

    Excel和Python这两个世界正在碰撞,这要归功于Microsoft的新集成,以促进数据分析和可视化 Microsoft正在将流行的编程语言Python引入Excel。该功能的公共预览版现已推出,允许Excel用户操作和分析来自Python的数据。 “您可以使用 Python 绘图和库在 Excel 中操作和浏览数据,然后使用

    2024年02月11日
    浏览(61)
  • Microsoft Azure Active Directory SAML JAVA集成

      Azure官网 环境配置 1.登录Azure官网进入Azure Active Directory 2.再选择Enterprise applications 3.新建自定义应用 4.配置应用的SSO,需要指定     Entity ID 唯一实例名,可以设置你的应用地址     ACS URL 断言响应地址 5.查看生成的SAML证书 App Federation Metadata Url    保存XML中idp X509Certificat

    2024年02月05日
    浏览(16)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包