python基础知识

输出函数

#字符串输出
print('helloworld')

#数字输出
print(520)

#含有运算表达式
print(520+1)

#将数据输出到文件中 如果文件存在就直接输出，如果不存在，在前面加一个fp=
fp=open('D:/python/text.txt','a+') #a+：如果文件不存在就创建，存在就追加输出
print('helloworld',file=fp)
fp.close()

#不进行换行输出
print('helloworld','pyhton')

转义字符

#转义字符
print('hello\nworld') #换行
print('hello\tworld') #4格
print('hello\rworld') #回车，会覆盖前面的
print('hello\bworld') #退一格，会覆盖前面一个空
print('https:\\\\www.baidu.com')
print('我：\'你好\'')

#原字符 让转义字符不起作用，就在字符串前加r
print(r'hello \n world')

python标识符

name='l'
print('标识',id(name))
print('类型',type(name))
print('值',name)

进制

print("十进制",20)
print("二进制",0b10011)  #二进制：前面加0b
print("八进制",0o1234567) #八进制，前面加0o
print("十六进制",0x1234abce) #十六进制 0x

布尔类型

#boolean
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))

#布尔类型可以转化为数字进行计算
print(f1+1)
print(f2+1)

字符串类型

#str
str1='人生苦短，及时行乐'
str2="人生苦短，及时行乐"
str3='''人生苦短，  #三引号可换行输入
及时行乐'''
print(str1,str2,str3,type(str1))

数据类型转换

#数据类型转换
name='张三'
age=20
print('我叫'+name+'今年'+str(age)+'岁') #在age前加str()

s1='125'
i1=50
f1=12.5
s2='hello'
s5='15.5'
print(int(s1)+i1+int(f1))  #187
# print(int(s1)+i1+int(f1)+int(s2))  #文字类型的str不能转成int
# print(int(s5))  小数点类型的字符串不能转换为int

s3='15.5'
s4='19'
f2=True
print(float(s3)+float(s4)+float(f2))  #35.5
print(float(s4))  #19.0

python的注释

单行注释：#单行注释

多行注释：‘’’ 多行注释 ‘’’

输入函数

input()

#输入函数
a = input('你想要什么礼物呢？\n')
print(a,type(a)) #类型为str

#转为int类型
a=int(input('输入一个加数：\n'))
b=int(input('输入一个数\n'))
print(a+b)

运算符

算术运算符

#运算符
print(1+1)
print(1-1)
print(2*4)
print(5/2)  #除法运算  2.5
print(5//2) #整除运算   2
print(5%2)  #取余运算  1
print(2**3) #2的三次方  8
print(-9//4) #向下取整 -3

print(-9%4)  # 3  余数=被除数-除数*商  （-9） - 4*（-3） = 12 -9 = 3
print(9%-4)  # -3   9- （-4）*（-3）= 9-12 = -3

赋值运算符

#链式赋值  id都一样
a=b=c=20
print(a,id(a))
print(b,id(b))
print(c,id(c))

#支持参数赋值
a=20
a+=30  #50
a-=10  #40
a*=2   #80
a/=3   #26.6666
a//=2  #13.0
a%=3   #1.0
print(a)

#解包赋值
a,b,c=10,20,30
print(a,b,c)

数值交换

a,b=10,20
print('交换之前：',a,b)
a,b=b,a
print('交换之后：',a,b)

比较运算符

#比较运算符  比较运算符的结果为boolean类型
a,b=10,20
print('a>b吗',a>b)
print('a=b吗',a==b)
#=为赋值运算符 ==比较运算符 ==比较的是值   is比较的是标识（id）

c,d=10,10
print(c==d)   #true
print(c is d) #true  id相同
print(id(c),id(d))

list1=[11,22,33]
list2=[11,22,33]
print(list2==list1)  #true
print(list2 is list1) #falst id 不同

布尔运算符

位运算符

运算符优先级

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

对象的布尔值

#bool  以下都为False ,其他都为true
print(bool(0))
print(bool(0.0))
print(bool(False))
print(bool(None))
print(bool(''))
print(bool([]))  # 空列表
print(bool(list())) #空列表
print(bool(tuple())) #空元组
print(bool(dict())) #空字典
print(bool({}))   #空字典
print(bool(set())) #空集合

分支结构

#分支结构
money=1000;
s=int(input('请输入取款余额\n'))
if money>=s :
    money-=s;
    print("取款成功,您的余额还有：",money)
else:
    print("取款失败，余额不足,您的余额为：",money)

多分支结构

#多分支结构
score=int(input("请输入成绩\n"))
if score>=90 and score<=100 :
    print("A")
elif score>=80 and score<90 :
    print("B")
elif score >=70 and score<80:
    print("C")
elif score >=60 and score<70 :
    print("D")
elif score<0 or score>100 :
    print("错误")
else:
    print("E")
    
#python中独特写法   90<=score<=100
score = int(input("请输入成绩\n"))
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 score < 0 or score > 100:
        print("错误")
else:
        print("E")

嵌套if结构

#嵌套if
money = int(input("请输入金额\n"))
a = int(input("你是否是会员,0 or 1\n"))
if bool(a) :
    if money>200 :
        print("你需要支付:",money*0.8)
    elif 100<=money<200 :
        print("你需要支付：",money * 0.9)
    else: print("你需要支付",money)
else :
    if money>200 :
        print("你需要支付:",money*0.95)
    else: print("你需要支付:",money)

条件表达式

#条件表达式  条件判断为true 就执行if左边的语句   为false 执行右边的语句
a=int(input("输入一个数\n"))
b=int(input("输入第二个数\n"))
print((a,"大等于",b) if a>=b else (a,"小于",b))

pass 暂停

for i in range(1,10):
    pass
print('暂停')
print(i)

range函数

r1=range(10) #[0,9]
r2=range(5,10) #[5,9]
r3=range(5,10,2) #5 7 9
print(list(r1),list(r2),list(r3))

while循环

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

for in 循环

for i in range(1,101):
    if i%2==0:
        sum+=i
print(sum)

水仙花数

for i in range(100,1000):
    ge=i%10
    shi=i//10%10
    bai=i//100
    if ge**3+shi**3+bai**3==i:
        print(i)

break

for i in range(3):
    name=input('输入用户\n')
    pwd=input('输入密码\n')
    if name=='myd' and pwd=='123456' :
        print("登陆成功")
        break
    else:
        print('用户或密码错误')

continue

结束本次循环

for i in range(100):
    if i%7!=0:
        continue
    print(i)

列表list

用[]存储不同的数据类型

切片

print(service[1:])   ##打印第一个元素之后的内容
print(service[:-1])  ##打印最后一个元素之前的内容
print(service[::-1])  ##倒序输出

连接

list1=['hello','world']
list2=['python']
print(list1+list2)

遍历

list1=['hello','world']
for i in list1:
    print(i)

嵌套列表

list1=[['hello','world'],[1,2,3],['python']]
print(list1[0][1]) #world

判断天

 User_input = input('输入：年-月-日')
Year = int(User_input.split('-')[0])   ##得到年份
Month = int(User_input.split('-')[1])  ##得到月份
Day = int(User_input.split('-')[2])    ##得到天

li = [31,28,31,30,31,30,31,31,30,31,30,31]   ##所有平年各个月份的天数
num = 0    ##记录天数
if ((Year % 4 == 0) and (Year % 100 != 0) or (Year % 400 == 0)):    ##当闰年时：
    li[1] = 29   ##将二月的天数改为29
for i in range(12):  ##遍历月份
	if Month > i + 1:   ##i从0开始，假如是5月的某一天，i循环到3停止，经过0-1-2-3四次循环，取4个月份即取1-2-3-4月的所有天
		num += li[i]   ##将1-4月总天数求和
	else:            ##退出if判断后，当下一次循环时，i=4，i+1不满足if的条件，进入else，将最后5月的第几天加入总天数中
		num += Day
		break
print('这一天是%d年的第%d天' %(Year,num))

增加

1.print(service + ['firewalld'])   #用连接的方式
2.service.append('firewalld')   print(service)#append:追加一个元素到列表中
3.extend:拉伸 追加多个元素到列表中  service.extend(['mysql','firewalld'])
4.service.insert(1,'samba')  #在指定索引位置插入元素  #在第二个元素的位置插入samba作为第二个元素，

删除

1.service.pop()   #弹出最后一个元素
a = service.pop(x)  #弹出第x-1个元素  
2.service.remove('ssh') ##指定删除对象的名字 
print(service)
3.del service  ##删除列表

更改

list1[0]='www'
list1[1:3]=['aaa','bbb']
print(list1)

查看

service.count('ssh') #查看出现次数
service.index('iscsi')    #查看最小索引值
service.index('ssh',1,3)   #从1-3中查找【第二个元素和第三个元素之间】

排序

names = ['alice','Bob','coco','Harry']
names.sort()   #names 按照ASCLL排序   #先排序首字母为大写的，再排序首字母是小写的
names.sort(key=str.lower)   #相当于将所有元素转换为小写，再排序
names.sort(key=str.upper)   #相当于将所有元素转换为大写，再排序

列表生成式

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

管理系统

users=['lhq','myd','zjj']
pwds=['123','345','456']

print('欢迎使用管理系统\n')
inuser=input('请输入账号\n')
inpwd=input("请输入密码\n")

if inuser=='admin' and inpwd=='admin':
    print('登陆成功\n')
    while True :
        print('''
        菜单：
        1.添加成员
        2.删除成员
        3.修改成员
        4.查看成员
        5.退出
        ''')
        x=int(input('请选择你的操作\n'))
        if x==1:
            print('添加成员\n')
            newuser=input('请输入用户名\n')
            for i in users:
                if i==newuser:
                    print('该用户已存在\n')
                    break
                elif i==users[len(users)-1] :
                    users.append(newuser)
                    pwds.append(input('请输入密码\n'))
                    print("添加成功\n")

        elif x==2:
            print('删除成员\n')
            deleteuser=input('请输入要删除成员的用户名\n')
            for i in users:
                if i==deleteuser:
                    deleteindex=users.index(i)
                    users.remove(i)
                    pwds.pop(deleteindex)
                    print('删除成功\n')
                    break
                elif i==users[len(users)-1]:
                    print('没有找到该用户！\n')

        elif x==3:
            print('修改成员\n')
            updateuser=input("输入修改成员的用户名\n")
            for i in range(len(users)):
               if users[i]==updateuser:
                    users[i]=input('输入新成员用户名\n')
                    pwds[i]=input('输入新成员密码\n')
                    print('添加成功\n')
                    break
               elif i == len(users)-1:
                   print('没有找到该用户\n')

        elif x==4:
            print('查看全部成员\n')
            print('用户名\t 密码\t')
            findindex=len(users)
            for i in range(findindex):
                print('%s\t\t%s' %(users[i],pwds[i]))

        elif x==5:
            break

    print('谢谢使用!')
else:
    print('你输入的账号密码有误,登陆失败!')

字符串str

len()计算长度

a='helloworld'
print(len(a))

拼接

1. 可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。
   (1) 如果+两边都是字符串，则拼接。
   (2) 如果+两边都是数字，则加法运算。
   (3) 如果+两边类型不同，则抛出异常。

a='hello world '+'python'
print(a)

复制

a='hello world '+'python'
print(a*3)

不换行打印

print(a,end=' ') #在结尾加end=
print(20)

str()

把其他类型转换为字符串类型

[]

用于提取字符串中位置的字符

a='helloworld'
print(a[4])

#[起始偏移量 start：终止偏移量 end：步长 step]
str='hello world.com'
print(str[4:9]) #4-9
print(str[4:9:2]) #4-9，每个2字符
print(str[-9:-4]) #倒数9-4
print(str[::-2]) #倒数每2取1
print(str[:2]) #0-1

replace()替换

a='hellowolrd'
print(id(a))
a=a.replace('hello','你好')
print(id(a))  #id发生改变
print(a)
a=a.replace(a[1],'我')
print(a)

split()分割

split()可以基于指定分隔符将字符串分隔成多个子字符串（存储到列表中），如果不指定分隔符，则默认使用空白字符

a='he ll ow or ld'
print(a.split())
print(a.split('o'))

join()合并

通过指定字符去合并列表

a='he ll ow or ld'
b=a.split()
print(b)
print(''.join(b))

startswith和endwith 检测以什么开头和什么结尾 返回 Boolean类型

str='www.hello.com'
print(str.startswith('www'))
print(str.startswith('hello'))
print(str.endswith('com'))

字符串比较

我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。
我们使用 is / not is，判断两个对象是否同一个对象。比较的是对象的地址，即 id(obj1)是否和 id(obj2)相等。

strip()

删除头尾指定字符,默认空白字符

str='我 www. hello .com 我'
print(str)
print(str.strip('我'))  #删除头尾
print(str.lstrip('我')) #删除头部
print(str.rstrip('我')) #删除尾部

大小写转换

a='hello WORLD.com'
print(a.capitalize()) 
print(a.title())
print(a.upper())
print(a.lower())
print(a.swapcase())

center()、ljust()、rjust()这三个函数用于对字符串实现排版

a="SXT"
a.center(10,"*") # '***SXT****'
a.center(10) #' SXT '
a.ljust(10,"*") #'SXT*******'

python格式化

python字符串格式化符号：

%c：字符及其ASCII码
%s：字符串
%d：整数
%u：无符号整型
%o：无符号八进制数
%x：无符号十六进制数
%X：无符号十六进制数（大写）
%f：浮点数字，可指定小数点后的精度
%e：用科学计数法格式化浮点数
%E：作用同%e，用科学计数法格式化浮点数
%g：%f和%e的简写
%G：%f 和 %E 的简写
%p：用十六进制数格式化变量的地址

字典dict

dict()生成一个字典，映射对象（键，值）

d = dict() #创建空字典
dt = {}    #创建空字典
print(d,dt,type(d),type(dt))

d1 = dict(zip([1,2,3],["a","b","c"]))  #具有明显的映射关系
d2 = dict(zip(("a","b","c"),(1,2,3,5))) #第二个元组多个5，不影响映射。
d3={1:'a',2:'b'}
d1=dict(one=1,tow=2,three=3)
print(d1,d2,d3)

clear()

删除字典中所有的键值对

d1=dict(one=1,tow=2,three=3)
d1.clear()
print(d1)

copy()

复制一个新字典

import copy
 
d1 = {"小明":98,"小红":99,"小东":[33,56,65]}
print("原始数据：",d1)
 
d2 = d1 # 引用拷贝 d1和d2指向同一个内存地址，d2只是d1的一个别名。
d3 = d1.copy() #浅拷贝，d3和d2的父对象相互独立，但子对象[33,56,65]指向同一个内存地址。
d4 = copy.copy(d1) #深拷贝，父对象，子对象都相互对立。
 
d1["小明"] = 86 #将字典d1中父对象"小明"的分数修改为 86
d2["小东"].append(95)  #向字典d1中子对象列表[33,56,65]添加一个元素 95
 
print("修改后的数据:",d1) 
print("引用拷贝:",d2) #引用拷贝，父对象，子对象都改变
print("浅拷贝:",d3) #浅拷贝，父对象不改变，但子对象改变
print("深拷贝:",d4) #深拷贝，父对象，子对象都不改变。

formkeys()

创建一个新字典，以可迭代对象iterable中元素做字典的键，value 为字典所有键对应的初始值，默认值为None。

d1 = {}
d2 = {}
d3 = {}
d4 = {}
 
print(d1.fromkeys("123")) # iterable为字符串，value为默认值None
print(d2.fromkeys([1,2,"a"],["a",1])) #iterable为列表，value为列表
print(d3.fromkeys({1,"b",2},(1,2))) #iterable为集合，value为元组
print(d4.fromkeys({"a":1,"b":2},1)) #iterable为字典，value为数字 

get()

返回d[k],若字典d中无k键，则返回d

d = {"one":1,"two":2,"three":3}
print(d.get("one",666)) #键"one"存在，返回d["one"]，不返回d值 666
print(d.get("five",666)) #键"five"不存在，返回d值 666
print(d.get("five")) #键"five"不存在，返回d的默认值 None

items()

返回字典d中所有键值对

d = {"one":1,"two":2,"three":3}
print(d.items(),type(d.items()))

keys()

返回d中所有键的信息

d = {"one":1,"two":2,"three":3}
print(d.keys(),type(d.keys()))

values()

返回d中所有值的信息

d = {"one":1,"two":2,"three":3}
print(d.values(),type(d.values()))

pop()

键存在则返回相应的值，同时删除该键值对，否者返回默认值d。

d.pop(key,d) -> v 删除指定的键并返回相应的值。如果未找到key，则返回d（如果给定），否则引发KeyError错误

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
print(d.pop("one")) #返回 键"one"的值
print(d.pop("six",6)) #字典d中无 "six"键，返回d值给定
print(d)
print(d.pop("seven")) #字典d中无 "seven"键，且没有给定d值，程序报错

popitem()

随机从字典d中取出一个键值对，并以元组(key,value)的形式返回,同时将该键值对从字典d中删除。若字典d为空，则引发KeyError

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
d1 = dict() #创建空字典
print(d.popitem(),type(d.popitem))
print(d1.popitem()) #字典d1为空，程序会报错

setdefault()

如果字典d存在键k，则返回d[k],否者返回d,并将d[k]的值设为d,且将该键值对(k,d)保存在字典d中

d.setdefault(k,d) -> d.get(k,d) , also set d[k]=d if k not in d

d = {"one":1,"two":2,"three":3,"four":4,"five":5}
print(d.setdefault("one",36)) #字典d中存在键"one",返回键"one",对应的值
print(d.setdefault("six",6)) # 字典d中不存在键 "six",返回6,并将("six",6)键值对保存在字典d中
print(d) #字典d增加了一对新的键值对。

update()

将a中的所有对象添加到字典d中

d = {"one":1,"two":2}
d1 = {"three":3,"five":5} #字典
ls = [("six",6),("seven",7)] #包含元组的列表
t = (["eight",8],["ten",10]) #包含列表的元组
d.update(d1)
d.update(ls)
d.update(t)
d.update(eleven=11,twelve=12) #关键字
d.update(zip(["thirteen","fourteen"],[13,14])) #zip
print(d)
print(d.update(d1)) #返回值为空

元组tuple

#创建
t1 = tuple((1,2,3))         #创建了一个包括3个元素的元组对象
print(tuple1)
t2 = (1,2,3,4,5,6,7,8,9,10)
print(tuple2)
#当要创建的元组中只包含一个元素时，必须带逗号。如果不带逗号会将左右括号默认视为运算符。
tuple1= (100, )                     #创建一个元素的元组时，必须带有逗号
tuple2= (100)
print(tuple1[0])

删除

要是删除，不能只删除元组中的某个元素，如果要删除，那么就使用del删除整个元组。

tuple2 = (1,2,3,4,5,6,7,8,9,10)
print(tuple2)
#删除
del tuple2

集合set

创建集合

set1=set() #空集
set2=set(['hello','world'])
set3={'python','wwww'}
print(set2)

添加

add() update()

set3={'python','wwww'}
set3.add('world')
set3.update({'java','lhq'})  #一次添加多个元素 要加{}
print(set3)

删除

remove()

set3={'python','wwww'}
set3.remove('wwww')  #直接删除值，但是如果不存在，则会报错

discard()

set3={'python','wwww'}
set3.discard('wwwww') #不存在也不会报错

pop()

使用「pop」方法从集合中删除并且返回一个任意的值

print(set3.pop())  #随机删除并返回该值

clear()

删除集合中所有的值

集合关系

两个集合是否相等（元素相等就相等）

s1={1,2,8,9}
s2={2,8,1,9}
print(s1==s2)

子集

s1={10,20,30,40,50}
s2={10,20,40}
print(s2.issubset(s1))  #判断s2是否是s1子集
print(s1.issuperset(s2)) #s1是s2的超集

交集

intersection() &

s2={10,20,40}
s3={10,20,90}
print(s2.isdisjoint(s3)) #判断s2和s3是否没有交集  有交集着返回False 无交集返回True
print(s2.intersection(s3))  #返回交集的部分 {10,20}
print(s2 & s3)  #{10，20}

并集

union() |

s2={10,20,40}
s3={10,20,90}
print(s2.union(s3))  #交集  {10，20,40，90}
print(s2 | s3)

差集

difference() -

s2={10,20,40}
s3={10,20,90}
print(s2.difference(s3))  #差集 {40}
print(s2-s3)

对称差集

s2={10,20,40}
s3={10,20,90}
print(s2.symmetric_difference(s3)) #对称差集 {40,90}

集合生成式

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

迭代

sorted()

for i in set3:
    print(i)
#使集合变成有序的
print(sorted(set3))

删除重复元素

使用集合删除列表中重复元素

list(set(list))

 list1 =list(set([1, 2, 3, 1, 5]))
list2=[1,4,5,4,3,2,2,2,1,1]
print(list(set(list2)))  #快速删除集合中重复元素

函数

把具有独立功能的代码块组织为一个小模块，这就是函数

定义函数的格式

def 函数名():
    代码
  #def 开始函数定义，紧接着是函数名，括号内部为函数的参数，内部为函数的 具体功能实现代码
函数的调用：
函数名()

参数：

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

def add2num(a, b):  #a b 是形参
    c = a+b
    print c

add2num(110, 22) # 110 22 是实参

默认参数值

调用函数时，缺省参数的值如果没有传入，则取默认值 ,带有默认值的参数一定要位于参数列表的最后面

#def printinfo(age=20,name):
def printinfo(name,age=20):   #20为默认值
    print(name)
    print(age)
 
printinfo('lhq')    #lhq 20
print('lhq',19)    #lhq 19

不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名

def functionname(a *args, **kwargs):
#加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
#而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.

def fun(a,*b,**c):
    print(a)   #1
    print(b)   #(2,3,4,5,6)
    print(c)   #{'q':50,'w'=90}

fun(1,2,3,4,5,6,q=50,w=90)  

如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 *args的后面，
但如果有kwargs的话，kwargs必须是最后的

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
    
sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

返回值

#定义函数
def add2num(a, b):
    return a+b
    
add2num(100,200)

#类型注解和返回值注解
def func(date :list) ->list:
    return date

返回多个值

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)  # 输出(2, 1)

函数嵌套

def B(d):
    return d*2

def A(a,b):
    if a==b:
        c=B(a)-b
    else:
        c=a-b

    return c

print(A(20,20))  #20
print(A(19,10))   #9

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

局部变量

• 局部变量，就是在函数内部定义的变量
• 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
• 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

全局变量

既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

# 定义全局变量
a = 100

def test1():
    print(a) 

def test2():
    print(a)  

test1()
test2()

global

修改全局变量

a=100
def test1():
    global a
    a=200
    print(a)  #200

test1()

拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age

my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

递归函数

直接或间接调用函数本身

直接调用

def func():
    print('in func')
    func()
func()

间接调用

def foo():
    print('in foo')
    bar()

def bar():
    print('in bar')
    foo()
foo()

递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小；
回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯

def foo(n):
    if n == 1:
        return 1
    else:
        return n * foo(n-1)
print(foo(5))#120

1、它的运行需要较多次数的函数调用，如果调用层数比较深，每次都要创建新的变量，需要增加额外的堆栈处理，会对执行效率有一定影响，占用过多的内存资源。

2、递归算法解题的运行效率较低。在递归调用的过程中系统为每一层的返回点、局部变量等开辟了栈来储存。递归次数过多容易造成栈溢出等。

二分查找

def efcz(n,lis):
    mid=int(len(lis)/2)
    print(lis)
    if len(lis)==0:
        print('false')
        return 0
    if n>lis[mid]:
        lis=lis[mid+1:]
        efcz(n,lis)
    elif n<lis[mid]:
        lis=lis[:mid]
        efcz(n,lis)
    else:
        print('ture')

lis=[1,2,7,11,22,34,78,200,206,254]
efcz(78,lis)

lambda

lambda表达式，又称匿名函数，lambda 函数是匿名的

lambda匿名函数的格式:在lambda关键字之后、冒号左边为参数列表，可不带参数，也可有多个参数。若有多个参数，则参数间用逗号隔开；冒号右边的为表达式，其实lambda返回值是一个函数的地址，也就是函数对象

def fun(num1,num2,func):
    return func(num1,num2)

print(fun(8,6, lambda num1,num2:num1+num2))
print(fun(8,6,lambda num1,num2:num1-num2))

异常处理

索引越界

list1=[11,22,33,44] #索引从0开始
print(list1[4])
list1.append('a','b','c')   #一次只能增加一个

try

try:
    n1=int(input("输入一整数"))
    n2=int(input('输入一整数'))
    print(n1/n2)
except ZeroDivisionError:
    print('除数不能为0')
except ValueError:
    print('不能是字母')
except BaseException as e:
    print(e)

如果出错则执行except，否则执行else
finally无论是否出错都会执行

try:
    n1=int(input("输入一整数"))
    n2=int(input('输入一整数'))
    result=n1/n2
except BaseException as e:
    print(e)
else:
    print(result)
finally:
    print("谢谢使用")

模块

模块化是将程序分解为一个个的模块module，通过组合模块来搭建出一个完整的程序。

导入模块的2种方式：
方式一：import 包名.模块名 [as 别名] （别名可要可不要）
方式二： from 包名 import 模块名
from 包名.模块名 import 变量|函数|类
sys：获取python解析的信息
os：对操作系统进行访问，主要是对目录或文件操作
math：数学运算
random：生成随机数
datetime:处理日期和时间，提供了多个类（dimedelta是处理时间类）
time：处理时间，关于时间加减

https://blog.csdn.net/qq_40674583/article/details/81940974?ops_request_misc=&request_id=&biz_id=102&utm_term=python%E6%A8%A1%E5%9D%97&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-0-81940974.nonecase&spm=1018.2226.3001.4187

面向对象

　1、多态（polymorphism）：一个函数有多种表现形式，调用一个方法有多种形式，但是表现出的方法是不一样的。

　　2、继承（inheritance）子项继承父项的某些功能，在程序中表现某种联系

　　3、封装（encapsulation）把需要重用的函数或者功能封装，方便其他程序直接调用

　　4、类：对具有相同数据或者方法的一组对象的集合

　　5、对象：对象是一个类的具体事例

　　6、实例化：是一个对象事例话的实现

　　7、标识：每个对象的事例都需要一个可以唯一标识这个事例的标记

　　8、实例属性：一个对象就是一组属性的集合

　　9、事例方法：所有存取或者更新对象某个实例一条或者多条属性函数的集合。

　　10、类属性：属于一个类中所有对象的属性，

　　11、类方法：那些无须特定的对性实例就能够工作的从属于类的函数。

封装

class Foo:
 
    def __init__(self, name, age ,gender):
        self.name = name
        self.age = age
        self.gender = gender
 
    def eat(self):
        print "%s,%s岁,%s,吃奶" %(self.name, self.age, self.gender)
 
    def he(self):
        print "%s,%s岁,%s,喝水" %(self.name, self.age, self.gender)
 
    def shui(self):
        print "%s,%s岁,%s,睡觉" %(self.name, self.age, self.gender)
 
a = Foo('jack', 10, '男')
a.eat()
a.he()
a.shui()
 
b = Foo('rose', 11, '女')
b.eat()
b.he()
b.shui()

继承

class Animal:
 
    def eat(self):
        print "%s 吃 " %self.name
 
    def drink(self):
        print "%s 喝 " %self.name
 
    def shit(self):
        print "%s 拉 " %self.name
 
    def pee(self):
        print "%s 撒 " %self.name
 
class Cat(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'
 
    def cry(self):
        print '喵喵叫'
 
class Dog(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
 
    def cry(self):
        print '汪汪叫'
 

 
c1 = Cat('猫one')
c1.eat()
 
c2 = Cat('猫two')
c2.drink()
 
d1 = Dog('狗one')
d1.eat()

静态方法@staticmethod

@staticmethod 下面的函数和所属的类截断了，这个函数就不属于这个类了，没有类的属性了，只不是还是要通过类名的方式调用

eat方法就没有了类的属性了，所以获取不到self.name这个变量

正确示例： 
 
 
class Person(object):
    def __init__(self, name):
        self.name = name
 # @staticmethod
 # def eat(self):
 #       print("%s is eating" % self.name)
        
    @staticmethod  # 把eat方法变为静态方法
    def eat(x):
        print("%s is eating" % x)
 
 
d = Person("xiaoming")
d.eat("jack")   
 
#就把eat方法当作一个独立的函数给他传参就行了

成员

class a:  # 说明父类的私有成员无法在子类中继承
    def __init__(self):
        self.ge=123
        self.__gene=456
 
class b(a):
    def __init__(self,name):
        self.name=name
        self.__age=18
        super(b,self).__init__()  # 这一行会报错
    def show(self):
        print(self.name)
        print(self.__age)
        print(self.ge)
        print(self.__gene)  # 这一行也会报错
obj=b("xiaoming")
print(obj.name)
print(obj.ge)
# print(obj.__gene)  # 这个也会报错
obj.show()

特殊成员

1.__init__

__init__方法可以简单的理解为类的构造方法（实际并不是构造方法，只是在类生成对象之后就会被执行），之前已经在上一篇博客中说明过了。

2.__del__

__del__方法是类中的析构方法，当对象消亡的时候（被解释器的垃圾回收的时候会执行这个方法）这个方法默认是不需要写的，不写的时候，默认是不做任何操作的。因为你不知道对象是在什么时候被垃圾回收掉，所以，除非你确实要在这里面做某些操作，不然不要自定义这个方法。

3.__call__

__call__方法在类的对象被执行的时候（obj()或者 类()()）会执行。

4.__int__

__int__方法，在对象被int()包裹的时候会被执行，例如int(obj)如果obj对象没有、__int__方法，那么就会报错。在这个方法中返回的值被传递到int类型中进行转换。

5.__str__

__str__方法和int方法一样，当对象被str(obj)包裹的时候，如果对象中没有这个方法将会报错，如果有这个方法，str()将接收这个方法返回的值在转换成字符串。

6.__add__

__add__方法在两个对象相加的时候，调用第一个对象的__add__方法，将第二个对象传递进来，至于怎么处理以及返回值，那是程序员自定义的
class abc:
    def __init__(self,age):
        self.age=age
    def __add__(self,obj):
        return self.age+obj.age
a1=abc(18)
a2=abc(20)
print(a1+a2)
#执行结果：38

me这个变量

正确示例： 
 
 
class Person(object):
    def __init__(self, name):
        self.name = name
 # @staticmethod
 # def eat(self):
 #       print("%s is eating" % self.name)
        
    @staticmethod  # 把eat方法变为静态方法
    def eat(x):
        print("%s is eating" % x)
 
 
d = Person("xiaoming")
d.eat("jack")   
 
#就把eat方法当作一个独立的函数给他传参就行了

成员

class a:  # 说明父类的私有成员无法在子类中继承
    def __init__(self):
        self.ge=123
        self.__gene=456
 
class b(a):
    def __init__(self,name):
        self.name=name
        self.__age=18
        super(b,self).__init__()  # 这一行会报错
    def show(self):
        print(self.name)
        print(self.__age)
        print(self.ge)
        print(self.__gene)  # 这一行也会报错
obj=b("xiaoming")
print(obj.name)
print(obj.ge)
# print(obj.__gene)  # 这个也会报错
obj.show()

特殊成员

1.__init__

__init__方法可以简单的理解为类的构造方法（实际并不是构造方法，只是在类生成对象之后就会被执行），之前已经在上一篇博客中说明过了。

2.__del__

__del__方法是类中的析构方法，当对象消亡的时候（被解释器的垃圾回收的时候会执行这个方法）这个方法默认是不需要写的，不写的时候，默认是不做任何操作的。因为你不知道对象是在什么时候被垃圾回收掉，所以，除非你确实要在这里面做某些操作，不然不要自定义这个方法。

3.__call__

__call__方法在类的对象被执行的时候（obj()或者 类()()）会执行。

4.__int__

__int__方法，在对象被int()包裹的时候会被执行，例如int(obj)如果obj对象没有、__int__方法，那么就会报错。在这个方法中返回的值被传递到int类型中进行转换。

5.__str__

__str__方法和int方法一样，当对象被str(obj)包裹的时候，如果对象中没有这个方法将会报错，如果有这个方法，str()将接收这个方法返回的值在转换成字符串。

6.__add__

__add__方法在两个对象相加的时候，调用第一个对象的__add__方法，将第二个对象传递进来，至于怎么处理以及返回值，那是程序员自定义的
class abc:
    def __init__(self,age):
        self.age=age
    def __add__(self,obj):
        return self.age+obj.age
a1=abc(18)
a2=abc(20)
print(a1+a2)
#执行结果：38