python学习记录

print() 输出数字 字符串 含有运算符的表达式 print('hello','wolrd') 不进行换行输出

为什么转义字符\t有时候是三个空格 有时候是四个空格
需要转义字符在字符串中不起作用时 print(r'hello \n wolrd') 在前面加R或r 但最后一个字符不能是\ 可以是\

标识符和保留字

import keyword
print(keyword.kwlist)

变量

name='wangXu'
print(name)

变量的三部分 1标示（内存地址）（内置函数id()）2类型（数据类型）（内置函数type()）3值（具体数据）
变量名多次赋值后 会指向新的空间

int float str bool 

str 加 单引号

整数类型默认十进制 0b表示二进制 0o表示八进制 0x表示十六进制
浮点数类型计算不精确性 需要精确时 导入模块

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

bool值可以转成整数计算

f1=True
print(f1+1)

str可以使用单引号 双引号 三引号来定义 三引号可以用三个单引号或者三个双引号
单引号和双引号的定义只能定义在一行里 三引号的定义可以分在多行来写 输出的时候也会多行输出

name='张三'
age='20'
print('我叫'+name+'今年'+age+'岁')  #加号是连接符 age是int类型 不能和str类型连接 需要类型转换
print(我叫'+name+'今年'+(str)age+'岁')

float类型转换为int类型时只转换小数点之前的数
str转换为int类型时，只有当str是数字串时才可以转换 而且必须不是小数串 别的时候会报错
str转换成float类型时，str不能是非数字串，整数后面会加上.0

输入函数input()

a=input('请输入一个加数')
b=input('输入另一个加数')

print(a+b)
#会输出a和b的连接之后的字符串
#因为从键盘输入进来的都是字符串类型 即str类型 所以此处的加号起了连接作用
#解决方法
a=input('请输入一个加数')
a=int(a)
b=input('输入另一个加数')
b=int(b)
print(a+b)
#或者
a=int(input('请输入一个加数'))
b=int(input('输入另一个加数'))
print(a+b)

运算符

加减乘数跟//
//是整除运算 只取除了之后的整数部分 没有四舍五入
**是幂运算
一正一负的整除运算会向下取整

print(9//4)  #2
print(9//-4) #-3 

取余运算 余数=被除数-除数*商

解包赋值

a,b,c=20,30,40
a,b=b,a #交换a,b的值

布尔运算符

and or not in not in
print(a==1 and b==2) #当两个运算数都为True时 结果为True
print(a==1 or b==2)  #只要有一个运算数为True 结果为True
f = true
print(not f) #not 对bool类型的操作数取反

s='hello world'
print('w' in s) #True
print('k' not in s) #True

运算符优先级

算术运算符>位运算>比较运算>bool运算(and or)>赋值运算

pass语句 在没有想好代码怎么写的时候使用 相当于一个占位符

rang()的三种创建方式

r = range(10) #默认从0开始 默认相差1成为步长
r = range(1, 10) #指定了起始值 从1开始 到10结束 但是不包括10 默认步长为1
r = range(1,10,2) #从1开始 到10结束 步长为2
print(list(r))
#判断指定的整数在序列中是否存在 in , not in
print(10 in r)
print(10 not in r)
#range类型的优点 不管range对象表示的整数序列有多长 所有range对象占用的内存空间都是相同的
#因为只需要存储start stop 和 step 只有当用到range对象时 才会计算序列中的相关元素

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


sum=0
for item in range(1,101):
    if not bool(item%2)
        sum+=item

二重循环中 break和continue 只控制本层循环

列表可以存储N个元素 程序可以方便地对这些数据进行整体操作，相当于其他语言中的数组

#创建列表的第一种方式 使用[]
list=['hello','world',98]
print(id(list),type(list),list)
#第二种方式 使用内置函数list()
list2=list(['hello','world',98])

索引映射唯一一个数据
可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存

#列表的查询操作
list=['hello','world',98,'hello']
print(index('hello')) #如果存在重复元素 只会返回第一个重复元素的索引
print(index('hello',1,3)) #在指定范围内查找元素
#当查找不到时会出现错误ValueError
#获取单个元素时 根据正向索引或者反向索引
#获取列表中的多个元素
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1]) #start stop step 默认step=1 默认start=0
print(lst[1:6:]) #最后冒号不写也可以
print(lst[:6:1])
print(lst[1::1]) #stop默认为最后+1
#判断指定元素在列表中是否存在
#in not in 返回bool类型


#列表元素的增加操作
#append() 在列表末尾添加一个元素 
#extend() 在列表末尾至少添加一个元素
#insert() 在列表的任意位置添加一个元素
#切片 在列表的任意位置添加至少一个元素

lst=[10.20,30]
lst.append(100)
lst2=['hello','world']
lst.extend(lst2)
lst.insert(1,90) #把1的位置加上90 后续元素向后移
lst3=[True,False,'hello']
lst[1:]=lst3 #把0后面的全部切掉 换成lst3的所有元素


#列表元素的删除操作
#remove() 一次删除一个元素 重复元素只删除第一个 元素不存在则报错ValueError
#pop() 删除一个指定索引位置上的元素 索引不存在则IndexError 不指定索引的话则删除最后一个元素
#切片 一次至少删除一个元素
#clera() 清空列表
#del 删除列表

lst[1:3]=[] #会删除1-3之间的元素 
print(lst)
del lst #将列表对象删除


#列表元素的修改操作
lst[2]=100
lst[1:3]=[300,400,500,600]


#列表的排序操作
lst.sort()
lst.sort(reverse=Ture) 降序排序 false升序
sorted(lst) #会产生新的列表对象 原列表不会变化
sorted(lst,reverse=False)


#列表生成式
# i*i for i in range(1,10)
new_list=[i*2 for i in range(1,6)]
new_list=[2,4,6,8,10]

字典以键值对的方式存储数据 是一个无序的序列 也是可变序列

 #字典的创建
 #1使用花括号
 scores={'张三':100, '李四':50}
 #2使用内置函数dict()
 stuent=dict(name='jack', age=20)
 #空字典
 d={}


#字典中元素的获取 
#第一种
print(scores['张三'])
#第二种
print(scores.get('张三'))

方括号没找到时会报错 get会输出None 可以设置默认的Value

#判断 in not in
print('张三' in scores)
#删除
del scores['张三']
print(scores)
scroes.clear() #清空
#添加
scores['陈六']=98
#修改
scores['张三']=60
#获取所有的key
keys=scores.keys()
print(keys)
print(list(keys)) #将所有的key组成的视图转成列表
values=scores.valuse()
print(valuse)
print(list(valuse))
items=scores.items()
print(items) 
print(list(items)) #转换之后的列表元素是又元组组成的
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get[item])

字典的键值不允许重复 但Value可以重复
字典是一种空间换时间的数据结构

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

字符串跟元组是不可变序列
改变了之后会改变地址
但字典跟列表添加修改删除之后不会改变对象的地址

#元组的创建方式 
1
t=('python','hello','world')
t='python','hello','world'
#只包含一个元素的元组创建时需要逗号和小括号 不能省略
2
t=tuple(('python','hello','world'))
#元组的遍历
for item in t:
    print(item) 

#集合的创建方式
#第一种创建方式
s={2,3,4,5,5,6,7,7}
#集合中的元素不允许重复
#第二种创建方式 使用内置函数set
s1=set(range(6))
s1=set([1,2,3,4,5,6])
s1=set((1,2,3,4,5,6))
s1=set('python')
s1=set({1,2,3,4,5,6})
d1=set() #空集合
#判断操作 in not in
print(10 in s)
#新增操作
s.add(80)  #一次添加一个元素
s.update({200,300,400})  #一次至少添加一个元素
s.update([200,300,400])
s.update((200,300,400))
#删除操作
s.remove(100)
s.remove(500) #keyError
s.discard(500) #如果有就删除 没有也不会报错
s.pop() #删除任意的元素 不能指定参数
s.clear() #清空集合元素


#集合之间的关系
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2) #True 因为集合是无序的
s1={10,20,30}
s2={10,20}
print(s2.issubset(s1)) #True 子集关系
print(s1.issuperset(s2)) #True 超集关系
print(s2.isdisjoint(s1)) #True 交集


#集合的数学操作 
#1交集
s1={10,20,30,40}
s1={20,30,40,50}
print(s1.intersection(s2)) 
print(s1 & s2) #和上面一样的
#2交集
print(s1.union(s2))
print(s1 | s2)
#3差集
print(s1.difference(s2))
print(s1-s2)
#s2-s1的输出跟s1-s2的输出不一样
#对称差集
print(s1.symmetric_difference(s2))
print(s1^s2) #交换顺序 输出一样
#集合生成式
s={i*i for i in fange(10)}
#无序

字符串的驻留机制

对相同的字符串只保留一份拷贝 后续创建相同字符串时 不会开辟新的空间 而是把该字符串的地址赋给新创建的变量(多个相同的字符串会指向相同的地址)

驻留机制的几种情况

1字符串的长度为0或者1时
2符合标识符的字符串
3字符串只在编译时驻留 不在运行时驻留
4[-5,256]之间的数字

#字符串的查询操作
#index() rindex()
#find() rfind()
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
#一般使用find方法 不会出现异常 找不到会返回-1
#带r的是查找子串最后一次出现的位置

#字符串大小写转换操作
#upper() lower() swapcase() capitalize() title()
#所有全都转换大写 所有全都转换成小写 都会产生一个新的字符串对象
#把大写转换成小写 小写转换成大写 
#把第一个字符转换成大写 其余字符转换成小写
#把每个单词的第一个字符转换成大写 每个单词的其余字符转换成小写

#字符串内容对齐操作
#center() 居中 第一个参数指定宽度 第二个参数指定填充符 默认空格
#ljust() rjust() 
#zfill() 右对齐 用0填充 只接受一个参数宽度

#字符串分割操作
s='hello world python'
lst=s.split()  #从左侧开始分割 没有参数sep时默认分隔符为空格
s1='hello|world'
lst=s1.split(sep='|')
lst=s1.split(sep='|',maxsplit=1) #最大分割次数
lst=s.rsplit() #从右侧开始分割

#字符串的判断操作
#字符串的其他操作
s='hello python'
print(s.replace('python','Java'))
#可以指定最大替换次数

函数

#函数的创建
def calc(a,b):
    c=a+b
    return c
answer=calc(10,20)    
result=calc(b=10,a=20) # =左侧的变量名称称为关键字参数

#函数调用过程中 进行参数传递
#如果是不可变对象 在函数体的修改不会影响实参的值
#函数返回多个值时，结果为元组
def fun(*arg): #使用指针定义个数可变的位置形参 结果为一个元组
    print(arg) #可变的位置参数 只能是1个
def fun(**arg): #使用**定义个数可变的关键字形参 结果为一个字典
    print(arg)   #需要关键字 关键字参数也只能是1个
    #两个混起来定义是可以的
def fun(*arg,**arg): #要求位置形参放在关键字形参之前

def fac(a):
    if a==1
        return 1
    else 
        return a*fac(a-1)
        
def fib(n):
    if (n==1)
        return 1
    elif (n==2) 
        return 1
    else 
        return fib(n-1)+fib(n-2)