python初阶语法

python基础语法

长文警告！！！本文适合初学py的小白阅读(根据需要进行跳转)。

输出函数print()

#输出数字
print (98.5)

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

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

#将数据输出文件中，注意点，1.所指定的盘存在，2.使用file=fp
fp=open('D:/text.txt','a+')#文件不存在就创建，存在就在文件内容后面继续追加
print('helloworld',file=fp)
fp.close()

#不进行换行输出(输出内容在一行当中)
print('hello','world','Python')

转义字符与原字符

#转义字符
print('hello\nworld')#n--newline的首字符表示换行
print('hello\tworld')
print('helloooo\tworld')
print('hello\rworld')
print('hello\bworld')

print('http:\\\\www.baidu.com')
print('老师说：\"大家好。\"')

二进制与字符编码

print(chr(0b100111001011000))
print(ord('乘'))

#变量由三部分组成
name='阿丽亚'
print(name)
print('标识',id(name)) #表示对象所储存的内存地址
print('类型',type(name)) #表示的是对象的数据类型
print('值',name) #表示对象所储存的具体数据

name='王晨亮'
name='梁桐'
print(name)
#一个变量可以多次赋值，但多次复制后变量会指向一个新的空间

#整数类型 integer - int 二进制 - 0b 八进制 - 0o 十六进制 - 0x
n1=90
n2=-10
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))

print('十进制',1010)
print('二进制',0b1010)
print('八进制',0o1010)
print('十六进制',0x1010)

Python中常见的数据类型

#浮点类型 存储不精确性
a=3.1415926
print(a,type(a))
n1=1.1
n2=2.2
n3=2.1
print(n1+n2)
print(n1+n3)

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

#布尔类型
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
#转成整数计算
print(f1+1)
print(f2+1)

#字符串类型
str1='abc'
str2='''abc'''
print(str1,type(str1))
print(str2,type(str2))

类型转换与注释

name='刘'
age=20

print(type(name),type(age))#说明name与age的数据类型不相同
#print('我叫'+name+'今年,'+age+'岁')#当将str类型与int类型进行连接时，报错，解决方案，类型转换
print('我叫'+name+'，今年'+str(age)+'岁')#将int类型通过str()

print('---str()将其他类型转成str类型---')
a=10
b=198.2
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="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))) #字符串必须为数字串且为整形

print('---float()将其他类型转换成float类型---')
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)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
#print(float(s3),type(float(s3))) #非数字串不允许转换
print(float(i),type(float(i))) 

'''多行注释
多行哦'''

input()函数的使用

#输入函数input
prasent=input('大圣想要什么礼物呢？')
print(prasent,type(prasent))

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

运算符和其优先级

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

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

a=3+4
print(a)
b=c=d=20
print(d,id(d))
print(b,id(b))
print(c,id(c))

a=20
a+=30
print(a)
a*=2
print(a)
a/=30
print(a)
a%=3
print(a)

a,b,c=1,2,3
print(a,b,c)
a,b=10,20
print('交换前',a,b)
a,b=b,a
print('交换后',a,b)

a,b=10,20
print('ab吗?',ab)
print(a<b)
print(a<=b)
print(a=b)
print(a==b)
print(a!=b)

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

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)
print(lst1 is lst2 )
print(id(lst1))
print(id(lst2))
print(lst1 is not lst2)

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

print(a==1 or b==2)
print(a==1 or b<2)
print(a!=1 or b==2)
print(a!=1 or b!=2)

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

s='helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)

print(4&8) #按位与&，同时为1结果为1
print(4|8) #按位或|，同时为0结果为0
print(4<<1) #向左移动1位 相当于乘以2
print(4<<2) #向左移动2位
print(41) #向右移动1位，相当于除以二
print(42) #除以4

'''运算符优先级
0.()
1.算术运算 2.位运算 3.比较运算 
4.bool运算 5.赋值运算'''

对象的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

分支结构

#单分支结构
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语句

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语句，只是一个占位符
answer=input('您是会员吗?y/n')
if answer=='y':
    pass
else:
    pass

range()函数的使用

#range()的三种创建方式
# 第一种创建方式
r=range(10) #默认从零开始，默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列 --list是列表的意思

# 第二种创建方式
r=range(1,10) #指定起始值，从1开始到10结束(不包含10)
print(list(r))

#第三种创建方式
r=range(1,100,2) #步长为2
print(list(r))

print(9 in r)
print(8 not in r)

while循环

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

sum=0
a=1
while a<=100:
    if not bool(a%2):             # if a%2==0:
        sum+=a
    a+=1
print(sum)

for_in循环

for item in 'python':
    print(item)
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,else语句和嵌套循环

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

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)

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

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

列表

# 列表对象
# 创建列表的第一种方式,[]
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)

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

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

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

# 向列表末尾添加元素
lst=[10,20,30]
print(lst,id(lst))
lst.append(100)
print(lst,id(lst))
lst2=['hello','world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表末尾
lst.extend(lst2) # 向列表末尾添加多个元素
print(lst)
lst.insert(1,90) # 在任意位置上添加一个元素
print(lst)
lst3=[True,False,'hello']
lst[1:]=lst3 # 在任意位置添加N个元素
print(lst)

lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)
# lst.remove(100) #ValueError: 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)
new_lst=lst[1:3]
print('原列表',lst)
print('切片后列表',new_lst)
lst[1:3]=[]
print(lst)
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)
lst[1:3]=[300,400,500,600]
print(lst)

lst=[20,40,10,98,54]
print('排序前',lst,id(lst))
lst.sort() #升序
print('排序后',lst,id(lst))
lst.sort(reverse=True) #降序
print(lst)
lst.sort(reverse=False) #升序
print(lst)

lst=[20,40,10,98,54]
new_lst=sorted(lst) #产生一个新列表 升序
print(lst)
print(new_lst)
desc_lst=sorted(lst,reverse=True) #降序
print(desc_lst)

#列表生成式
lst=[i*i for i in range(1,10)]
print(lst)
lst2=[i for i in range(2,11,2)]
print(lst2)

字典

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

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

scores={'张三':100,'李四':98,'王五':45}
print("张三" in scores)
print("张三" not in scores)
del scores['张三'] # 删除指定的key-value对
# scores.clear() # 清空字典的元素
print(scores)
scores['陈六']=98 #新增元素
print(scores)
scores['陈六']=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))

d={'name':'张三','name':'李四'} # key不允许重复
print(d)
d={'name':'张三','nikename':'张三'} # value允许重复
print(d)

# 字典生成式 
items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
d={item.upper():price   for item,price in zip(items,prices)}
print(d)
lst=zip(items,prices)
print(list(lst))

元组

'''可变序列 列表，字典'''
lst=[10,20,45]
print(id(lst))
lst.append(200)
print(id(lst))
'''不可变序列 字符串，元组'''
s='hello'
print(id(s))
s=s+'world'
print(id(s))
print(s)

# 元组的创建方式
# 第一种，用()
t=('Python','world',98)
print(t)
print(type(t))

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

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

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

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

t=(10,[20,30],9)
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,id(t[1]))

#元组的遍历
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)

集合

# 集合的创建方式
# 1.{}
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)
#2.set()
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,4,5,5,5,6,6])
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))

#集合的相关操作
#判断操作
s={10,2,0,30,40,50}
print(10 in s)
print(100 in s)
print(0 not in s)
#新增操作
s.add(80) #一次添加一个
print(s)
s.update({200,300,4000}) #一次至少添加一个元素
print(s)
s.update([100,99,6])
s.update((78,56,48))
print(s)
#删除操作
s.remove(10)
print(s)
# s.remove(500) #KeyError: 500
# print(s)
# s.discard(500) #没有，不报错
# print(s)
s.pop() #只能删除第一个，且不能添加参数
print(s)
s.clear() #清空集合
print(s)

# 两个集合是否相等(元素相同，就相等)
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
print(s3.issubset(s1)) #F
print(s1.issuperset(s2)) #T
print(s1.issuperset(s3)) #F
#交集
print(s2.isdisjoint(s3)) #F - 有交集
s4={100,200,300}
print(s2.isdisjoint(s4)) #T - 没有交集

# 集合的数学操作
#(1)交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1&s2)

#(2)并集
print(s1.union(s2))
print(s1|s2)

#(3)差集
print(s1.difference(s2)) #s1有s2没有
print(s1-s2)
print(s2.difference(s1))

#(4)对称差集
print(s1.symmetric_difference(s2)) #集合交集以外的元素
print(s1^s2)

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

字符串

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

后面把a=sys.intern(b)中的 . 打成 , 报错，请忽略。

这里读者可以自行验证

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

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

#字符串的大小写转换操作
s='HelloWorld,wa'
print(s.upper(),id(s.upper())) #全转成大写
print(s,id(s))
print(s.lower()) #全转成小写
print(s.swapcase()) #大转小，小转大
print(s.capitalize()) #第一个字符大写，其余小写
print(s.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))
print('-8910'.zfill(8))

#字符串的劈分操作
s='hello world Python'
print(s.split())
s1='hello|world|Python'
print(s1.split())
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))
#从右侧分
print(s1.rsplit(sep='|',maxsplit=1))

#字符串判断的相关方法
#合法标识符
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

#字符串的其他操作
#字符串的替换
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))

print('*'.join('python'))

#字符串的比较操作
print('apple''app') #T
print('apple''banana') #F, 9798 F
print(ord('a'),ord('b')) #原始值这里是字母的ascll码
print(ord('刘'))
print(chr(97),chr(98))
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


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

print(s[1:5:1]) #完整写法 从一切到五步长为一
print(s[::2]) #从0开始
print(s[::-1]) #从最后一个元素开始
print(s[-6::1])

#格式化字符串
# % 占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
# {}
print('我叫{0},今年{1}岁'.format(name,age))
# f-string
print(f'我叫{name},今年{age}岁')

#宽度和精度
print('%10d' % 99) #10个宽度
print('%.3f' % 3.1415926) #.3表示小数点后三位
print('%10.3f' % 3.1415926) #宽度为10，保留三位小数
print('hellohello')
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数
print('{0:.3f}'.format(3.1415926)) #.3f表示3位小数
print('{0:10.3f}'.format(3.1415926)) #一共10位3位小数

#字符串的编码转换
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'))

函数

#函数
#函数的定义和调用
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)

#函数参数传递的内存分析
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的值'''

#函数的返回值
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())
'''函数在定义时，是否需要返回值，视情况而定'''

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

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

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

#函数的参数定义
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
在一个函数定义的过程中，既有个数可变的关键字参数，也有个数可变的位置形参，要求个数可变的位置形参，放在个数可变的关键字形参之前'''

#函数参数总结
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)  #函数调用时，将列表的每个元素都转换为位置实参传入
print('--------')
fun(a=100,c=300,b=200)  #关键字实参
dic={"a":111,'b':222,'c':333}
fun(**dic)  #在函数调用时，将字典的键值对都转换为关键字实参传入

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

#变量的作用域
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)

#递归函数
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

#bug
#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)'''
#try...except结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为零')
except ValueError:
    print('不能将字符转换为数字')
print('程序结束')
#try...except...else结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为：',result)
#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('程序结束')

#常见的异常类型
# 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模块的使用
import traceback
try:
    print('--------------')
    print(1/0)
except:
    traceback.print_exc()

编程的两大思想-面向过程、面向对象

#类与对象
#定义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))
print(type(stu1))
print(stu1)
print(id(Student))
print(type(Student))
print(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'

面向对象的三大特征

#面向对象的三大特征
#封装
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 进行访问

#继承
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)
        self.score=score
    def info(self):  #方法的重写
        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类 -- 所有类的父类
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)
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
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类的父类类型的元素
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  #实现两个对象的加法运算
print(s)
s=stu1.__add__(stu2)
print(s)

lst=[11,22,33,44]
print(len(lst))
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)
print(cpu2)
#(2)类的浅拷贝
disk=Disk()  #创建一个硬盘类的对象
computer=Computer(cpu1,disk)  #创建一个计算机类的对象

#浅拷贝
import copy
print(disk)
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)

模块

#模块
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))

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

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

#python中常用的内容模块
import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

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

def job():
    print('hh')

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

文件

#文件
#读
file=open('a.txt','r')
print(file.readlines())
file.close()
#写
file=open('b.txt','w')
file.write('hello')
file.close()
#追加
file=open('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()

#读
file=open('a.txt','r')
print(file.read(5))  #读取size个字节或字符
print(file.readline())  #读取一行内容
print(file.readlines())  #把文本文件中的每一行都作为独立的字符对象，并将这些对象放入列表返回
#写
file=open('c.txt','a')
# file.write('hello')
lst=['java','go','python']
file.writelines(lst)
file.close()
#移动文件指针
file=open('c.txt','r')
file.seek(1)  #将文件移动到新的位置
print(file.read())
print(file.tell())  #返回文件指针当前位置
file.close()

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

#with语句(上下文管理器)
with open('a.txt','r') as file:
    print(file.read())
#不用手动关闭

#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')
print(os.getcwd())  #返回当前的工作目录
lst=os.listdir('python')  #返回指定路径下的文件和目录信息
print(lst)
os.mkdir('TXT/1.txt')  #创建目录
os.rmdir('TXT')  #删除目录
os.removedirs('TXT/1.txt')  #删除多级目录
os.chdir('C:\\')  #改变工作路径
print(os.getcwd())

#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:\\','1.py'))  #目录和文件拼接操作
print(os.path.split('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #拆分路径和文件
print(os.path.splitext('helloworld.py'))  #拆分文件和后缀名
print(os.path.basename('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取文件名
print(os.path.dirname('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取目录名
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'):
        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))