Python学习笔记00

转义字符



一个\t占4个字符位

原字符
不希望字符串中的转义字符起作用，在字符串之前加上 r 或者 R ，且字符串最后一个字符不能是 \ 。






多次赋值后，变量名会指向新的空间（因为maria不再使用了，因此maria成了内存垃圾，将会由python垃圾回收机制来回收）

数据类型

常用的数据类型
整数类型 int 98
浮点数类型 float 3.1415926
布尔类型 bool true false
字符串类型 str ‘人生苦短，我用python’

整数类型 int


二进制用0b开头


八进制用0o开头


十六进制用0x开头

浮点数类型 float
浮点数存储不精确性（二进制的底层问题）


导入Decimal模块

布尔型 bool
表示真假，true 1，false 0

字符串类型


数据类型转换
int() 将其他类型转换成int类型
str() 将其他类型转换成str类型
flost() 将其他类型转换成float类型

注释

单行注释

三引号不赋值给任何变量就可以作为多行注释

输入函数input()


经过input()方法输入的是一个字符串，如果想进行算术运算需要进行类型转换

运算符

比较运算符





== 说明a与b的value值相等
is 说明a与b的id标识相等
a与b都指向了同一个id标识的对象，这个对象的value值是10，type是int类型
is not 比较两个变量的id是否不相等
is 比较两个变量的id是否相等
== 比较两个变量的value是否相等
布尔运算符
and 与
or 或
not 非
in
not in

Python一切介对象，一切对象都有一个布尔值
获取对象的布尔值用bool()函数

Pass语句
什么都不做，只是一个占位符，用到需要写语句的地方

range()函数
用于生成一个整数序列
不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅存储start、stop、step，只有当用到range对象时，才会去计算序列中的相关元素。
#range()三种创建方式
#默认从0开始，默认相差为1称为步长 range(stop)
r=range(10)
#用于查看range对象中的整数序列 list是列表的意思
print(list®)
#从指定位置开始,到stop结束，不包括stop range(start,stop)
r=range(10,11)
print(list®)
#从指定位置start开始,到stop结束，不包括stop，步长为step range(start,stop,step)
r=range(1,10,2)
print(list®)

列表
列表可以存储多个元素，相当于数组

列表中存储的不是对象，而是对象的引用

li=[‘hello’,‘world’,98]

print(id(li))

print(type(li))

print(li)

列表的创建

#方式一
li=[‘hello’,‘world’,98]
#方式二
li2=list([‘hello’,‘world’,98])
#获取列表中指定元素的索引
li3=list([‘hello’,‘world’,98,‘hello’,‘hinata’])
#列表中存在n多个相同元素，只返回相同元素中的第一个元素的索引
print(li3.index(‘hello’))
#如果查找的元素在列表中不存在，会抛出VlaueError
#可以再指定的范围内进行查找
print(li3.index(98,0,3))
#获取索引为2的元素 正向索引
print(li3[2])
#逆向索引
print(li3[-1])
#获取列表中的多个元素
#li3[start:stop:step] step:步长
print(li3[0👎1])#生成了一个新的列表对象
print(li3[::-1])#元素逆序输出li3[ : :-1]
print(li3[4::-1])#元素逆序输出li3[stop: :-1]
#遍历列表
for i in li3:
print(i)
################# 列表元素添加操作
li3.append(‘naruto’)#列表尾部添加一个元素
print(li3)
li3.extend(‘abc’)#列表尾部至少添加一个元素
print(li3)
li3.insert(0,‘haiyashi’)#在指定位置添加元素
print(li3)
li4=[‘kobayashi’,44,55]
li3[0:1]=li4#在指定位置添加多个元素
print(li3)

########## 列表元素的删除

li3.remove(‘kobayashi’)#从列表中移除一个元素，如果有重复元素只移出第一个元素

print(li3)

li3.pop()#删除指定位置的元素，如果不指定索引，默认删除最后一个元素

print(li3)

li3.clear()

print(li3)

del li3#删除列表对象

########## 列表元素的修改

li3[2]=15

print(li3)

li3[0:3]=[1,2,3]

print(li3)

############ 列表的排序操作
li5=[99,6,5,0,2,58,5,1,2,25,7,65,10]
print("排序前的 : ",li5,id(li5))
#开始排序 sort()默认升序

li5.sort()

print("排序后的 : ",li5,id(li5))

li5.sort(reverse=True)#降序排列 reverse=False是升序，不指定reverse的话默认就是False

print("降序排列 : ",li5,id(li5))

#使用内置函数sorted()进行排序，将产生一个新的列表对象
new_li5=sorted(li5)
print("排序后的 : ",new_li5,id(new_li5))
new_li55=sorted(li5,reverse=True)
print("降序排序 : ",new_li55,id(new_li55))

########## 列表生成式
li6=[i*i for i in range(0,10)]
print(li6)
li7=[i for i in range(0,10,2)]
print(li7)

字典
一个可变序列，以键值对的方式存储数据，字典是一个无序的序列
Key是不可变序列
特点
所有元素都是键值对，键不可以重复，值可以重复；
元素都是无序的
键是不可变对象
字典可以根据需要动态地伸缩
字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典的创建

方式一

score={‘tom’:100, ‘张三’:99, 88:101}
print(score,type(score),id(score))

方式二

student=dict(name=‘tom’, age=18, salary=‘man’)
print(student)

空字典

d={}
print('空字典 d : ',d)

字典元素的获取

方式一

print(score[‘张三’])

print(score[100])#不存在的键会报错

方式二

print(score.get(‘tom’))
print(score.get(100))#不存在的键会提示None
print(score.get(‘hayashi’,100))#给不存在的键设置默认值

键的判断

print(‘tom’ in score)

print(‘tom’ not in score)

删除指定的键值对

del score[‘tom’]

score.clear()# 清空字典元素

print(score)
dic={‘a’:1,‘b’:2,‘c’:3}
#删除字典最后一个元素
dic.popitem()
#按键删除
dic.pop(‘a’)
print(dic)

‘’’# 字典元素的修改’’’
print(score)
score[‘tom’]=0
print(score)

‘’’# 字典的视图操作’’’
‘’’#获取所有的键’’’
keys=score.keys()
print(keys,type(keys))
print(list(keys))#’’‘将所有的键转换成列表元素’’’
‘’’#获取所有的值’’’
values=score.values()
print(values,type(values))
print(list(values))
‘’’#获取所有键值对’’’
items=score.items()
print(items,type(items))
‘’‘转变之后的列表元素是由元组组成’’’
print(list(items))

‘’‘字典元素的遍历’’’
for item in score:
print(‘键’,item,‘值’,score[item],‘值’,score.get(item))
‘’‘字典生成式’’’
it=[‘hayashi’,‘hinata’,‘sarana’,‘naruto’]
prices=[1,2,3]
d={itemm.upper():pricee for itemm,pricee in zip(it,prices)}
print(d)

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

不可变序列：字符串、元组
没有增删改的操作
可变序列：列表、字典
可以增删改，对象地址不发生改变
元组为什么是不可变序列
多任务环境下，同时操作对象时不需要加锁
元组中存储的是对象的引用
如果元组中对象本身
‘’‘元组的创建方式’’’
#方式一
t=(‘Python’,‘world’,98)
print('t : ',t,type(t))
t0=‘sakura’,‘sasuke’,‘sarana’
print('t0 : ',t0,type(t0))
#方式二 用内置函数tuple()
t1=tuple((‘hinata’,‘naruto’,‘boruto’,‘himawari’))
print('t1 : ',t1,type(t1))
t2=(10,)#元组中只有一个元素需要使用逗号和小括号
print('t2 : ',t2,type(t2))
#空列表
ls=[]
ls1=list()
#空字典
d={}
d1=dict()
#空元组
t3=()
t4=tuple()
print(t3,t4,type(t3),type(t4))
print(‘空列表’,ls,type(ls),ls1,type(ls1))
print(‘空字典’,d,type(d),d1,type(d1))
print(‘空元组’,t3,type(t3),t4,type(t4))

t5=(10,[20,30],40)
print('t5[0] : ',t5[0],type(t5[0]),id(t5[0]))
print(‘t5[1] : ‘,t5[1],type(t5[1]),id(t5[1]))
print(‘t5[2] : ‘,t5[2],type(t5[2]),id(t5[2]))
‘’‘由于t5[1]是列表，而列表是可变元素，因此可以对列表中的元素进行操作，而列表的内存地址不变’’’
‘’‘类似指针常量’’’
t5[1].append(35)#列表中添加元素
print('t5[1] : ',t5[1],type(t5[1]),id(t5[1]))
print('t5 : ',t5,type(t5),id(t5))

#元组的遍历
t6=(‘1’,‘2’,100)
for item in t6:
print(item)

集合
可变序列
只有key没有value的字典
底层数据结构采用hash表
元素不允许重复
‘’‘创建方式’’’
s={0,1,2,3,4,5,6,7,8,9,8,7}
print(s)
‘’‘创建方式二’’’
s1=set(range(6))
print(s1,type(s1))

s2=set(‘python’)#将python中的每一个字符转换成集合中的元素
‘’‘相关操作’’’

‘’‘判断操作’’’
hh={1,2,3,4,5,5,‘45’,2,‘dyvjb’,53,2,85}
print(10 in hh)
print(‘45’ in hh)
print(10 not in hh)

‘’‘新增操作’’’
hh.add(‘hinata’)#一次添加一个元素
print(hh)
hh.update({‘aa’,‘bb’,‘cc’})#一次至少添加一个元素
print(hh)

‘’‘删除操作’’’
hh.remove(‘cc’)
print(hh)

hh.remove(‘dd’)#删除不存在的元素会报错

hh.discard(‘dd’)#删除不存在的元素不会报错
hh.pop()#随机删除一个元素

hh.pop(2)#不能添加参数

hh.clear()#清空集合元素
print(hh)

‘’‘集合间的关系’’’
‘’‘两个集合是否相等’’’
aa={10,20,30,40}
bb={30,40,20,10}
print(‘aabb?’,aabb)
print(‘aa!=bb?’,aa!=bb)
‘’‘一个集合是否是另一个集合的子集 元素相同，就相等’’’
ab={10,20,30,40,50,60}
ba={10,20,30,40}
aab={10,20,100}
print(‘ba是ab的子集么?’,ba.issubset(ab))
print(‘aab是ab的子集么?’,aab.issubset(ab))
print(‘ab是ba的子集么?’,ab.issubset(ba))
‘’‘一个集合是否是另一个集合的超集’’’
print(‘ab是ba的超集么?’,ab.issuperset(ba))
print(‘ab是aab的超集么?’,ab.issuperset(aab))
print(‘ba是aab的超集么?’,ba.issuperset(aab))
‘’‘两个集合是否不相交’’’
print(‘ab和ba是否不相交?’,ab.isdisjoint(ba))
print(‘ab和aab是否不相交?’,ab.isdisjoint(aab))
print(‘ba和aab是否不相交?’,ba.isdisjoint(aab))

‘’‘交集操作’’’
s1={10,20,30,40,100}
s2={10,20,30,40,50,60}
print(‘交集’,s1.intersection(s2))
print(‘交集’,s1 & s2)
‘’‘并集操作’’’
print(‘并集’,s1.union(s2))
print(‘并集’,s1 | s2)
‘’‘差集操作’’’
print(‘差集’,s1.difference(s2))
print(‘差集’,s1 - s2)
‘’‘对称差集’’’
print(‘对称差集’,s1.symmetric_difference(s2))