python基础语法 python基础

Number类型，字符串，列表，元组，集合，字典，变量的缓存机制，Number强制类型转换，自动类型转换，容器类型转换，字典类型的强转，判断类型，算数_比较_赋值_成员，逻辑运算，位运算符，代码块_单项_双项分支,多项分支，循环结构，字符串的切片，break pass continue，for循环，format格式化，填充符，字符串相关方法，列表相关操作，列表相关函数，深浅拷贝，字典相关函数，集合相关操作函数基础数据类型1.数字类型（int float bool complex）(1)int 整数（正整数 0 负整数）type 获取值的类型res = =type(invar)print(res)id 获取值的地址res = id(intvar)print(res) 二进制整形intvar = 0b110print(intvar)print(type(intvar))print(id(intvar))八进制整形intvar = 0o127print(intvar)print(type(intvar))print(id(intvar))十六进制intvar = 0xffpromt(intvar)print(type(intvar))print(id(intvar))小结：
二进制1+1=10
八进制7+1=10
十六进制f+1=10
(2) float 浮点型（小数）浮点型简单来说就是表示带有小数的数据,而恰恰小数点可以在相应的二进制的不同位置浮动,可能是这样就被定义成浮点型了。
# 表达方式1
floatvar = 3.6 print(floatvar,type(floatvar))

# 表达方式2 科学计数法
floatvar = 5.7e5# 小数点右移5位
floatvar = 5.7e-5# 小数点左移5位
print(floatvar,type(floatvar)) （3）bool 布尔型（True 真的，False 假的）boolvar = Tureprint(boolvar,type(boolvar))(4) complex 复数类型'''3 + 4j实数+虚数实数：3虚数4jj ：如果有一个数他都平方等于-1，那么这个数就是j，科学家认为有，表达一个高精度的类型'''表达方式1complexvar1 = 3 + 4jcomplexvar2 = -3j#虚数部分可以是负数是复数类型print(complexvar1,type(complexvar1))print(complexvar2,type(complexvar2))

表达方式2
'''
complex(实数，叙述) ==> 复数
'''
res = complex(3,4)
print(res,type(res))2.字符串（str）类型'''
有引号的就是字符串，单引号，双引号，三引号
# 转义字符\ +字符
（1）可以将无意义的字符变得有意义
（2）可以有意义的字符变得无意义
\n：换行
\r\n：换行
\t ：缩进（水平制表符）默认四个空格距离
\r ：将\r 后面的字符串拉到了当选行的行首
'''
（1）单引号的字符串strvar = '生活不止眼前的苟且'print(savar,type(strvar))（2）双引号的字符串strvar = ''还有诗和远方的田野''print(savar,type(strvar))strvar = ''还有诗和\n远方的田野''print(strvar)

#可以将无意义的字符变得有意义strvar = ''还有诗和\r\n远方的田野''
print(strvar)strvar = ''还有诗和\t远方的田野''
print(strvar)strvar = ''还有诗和\r远方的田野''
print(strvar) strvar = ''还有诗和\n远方的\r田野''
print(strvar)

#可以将有意义的字符变得无意义
strvar = ''还有诗\"远\"方的田野''
print(strvar)（3）三引号的字符串(可以支持跨行效果)strvar = '''strvar = '''
生活就像醉酒表面上说不要身体却很诚实'''
print(strvar)

#下面这么写也是可以的stavar = '''
生活就像"醉"酒
表面上说'不'要
身体却很诚实
'''
print(strvar)
python中单引号双引号没有区别但是在其他语言中有区别
比如说php
$a = "123""{$a} => "123"'{$a}' => '($a)'单引号当做普通字符串（4）元字符串 r"字符串" 原型化输出字符串strvar = 'D:\python32_python\tar02'#这是个路径很明显这个字符串前面没加r 很乱输出不对
print(stavar) r"字符串" 原型化输出字符串
strvar = r'D:\python32_python\tar02'
print(strvar)
#这回就对了

（5）字符串的格式化比如说小张买了三个药水李四买了四个药水张三买了五个药水你会发现这些话整体来说除了数量在改变字符串并没有改变
'''%d整型占位符%f浮点型占位符%s字符串占位符'''strvar = '张三昨天买了%d个风油精，洗澡' %（2）print(strvar)

接下俩看这个
%2d 占两位（不够两位拿空格来部位）原字符串在右面strvar = '张三昨天买了%2d箱风油精，洗澡' %（2）
print(strvar)

# %-2d占两位（不够两位拿空格来部位）原字符串在左面

strvar = '张三昨天买了%-2d'箱风油精，洗澡' %（2）
print(strvar)

# %f 浮点型占位符（存在四舍五入的情况，默认保留6位小数）
strvar = '阎王爷一个月开%f工资'%(9.9)
print（strvar）
# 我么会发现打印出来的结果是这样的阎王爷一个月9.900000工资小数点后保留了6位小数
# 下面有一种方法可以保留小数点后两位小数

# %.2f 保留小数点后两位小数 strvar = '阎王爷一个月开%.2f工资'%(9.9178)
print（strvar）

%.xf x = 任意数字是几小数点后面就保留几位小数

# %s 字符串占位符
strvar = "%s最喜欢在电影院尿尿" %（"李白"）
print（strvar）

#综合案例
strvar = "%s在水里%s被发现了，罚了%.2f元，并且做了%d个俯卧撑" （"张三"，"拉屎"，500.129,50000）
print(strvar)

# 如果忘记用什么占位符，可以无脑用%s 。strvar = "%s在水里%s被发现了，罚了%s元，并且做了%s个俯卧撑" （"张三"，"拉屎"，500.129,50000）
print(strvar) 3.列表类型（list）定义一个空列表
listvar = []print(listvar,type(liatvar))定义普通列表
listvar = [98,6.9,Tyre,12-90,"张三"]获取列表中的元素
在python分为正向索引和逆向索引
正向索引（从0开始） 0 1 2 3 4 ......
0 1 2 3 4
listvar = [98,6.9,Tyre,12-90,"张三"] -5 -4 -3 -2 -1
逆向索引（只有python可以）（从-1开始） -1 -2 -3 -4 -5
len() 获取容器类型数据中元素的个数
listvar = [98,6.9,True,12-90j,"张三"]print(len(listvar))# python逆向索引的特点，瞬间得到列表最后一个索引
listvar = [98,6.9,True,12-90j,"张三"]
print(listvar[-1]) # 修改列表中的元素
listvar = [98,6.9,True,12-90j,"张三"]l1= listvar[3] = "大象"print(l1)4.元组类型（tuple）特征：只能获取，不可以修改，有序
定义一个元组
tuplevar = ('张三','李四','熊大')print(tuplevar,type(tuplevar))获取元组中的元素
正向索引
#下面要获取熊大tuplevar = ('张三','李四','熊大')print(tuplevar[2])逆向索引
逆向获取熊大tuplevar = ('张三','李四','熊大')print(tuplevar[-1]) 修改元组中的元素：元组中的值不能修改
注意点
我们发现下面打印结果并不是元组类型
tuplevar = (1)
print(tuplevar)
print(type(tuplevar))
#打印结果1
<class 'int'>
接下来我们看下一个
tuplevar = (1,)print(tuplevar)print(type(tuplevar))#打印结果(1,)<class 'tuple'>我们发现添加个逗号打印结果是元组类型
总结：逗号才是区分是否是元组的标识符
定义空元组
tuplevar = ()print(type(tuplevar))这个打印结果也是元组但是没加逗号这是为什么呢？
因为里面没有值是一个空元组
字符串类型（补充）
'''
特征：可获取，不可修改，有序
'''
正向索引
strvar = "大妹子，我一看你，我就心跳加速，喘不上气儿"print(stavar[3])
#打印结果：，我们发现空格和符号都占有一个索引位置
5.集合类型 set（交差并补）setvar = {"Amy","Sam","谣","帅"}print(setvat,type(setvar))我们打印发现每次的结果都不一样，所以说集合是无序的
获取集合中的元素
setvar = {"Amy","Sam","谣","帅"}setvar[1]获取我们发现报错那是为什么呢？
刚刚说过集合是无序的所以说没有办法按照索引来获取集合中的元素
接下来再看几行代码
setvar = {"Amy","Sam","谣","帅","Sam"}print(setvar)我们打印完发现原本集合中有两个Sam 却只输出了一个Sam 这说明集合具有自动去重功能
我们再看看下面的代码看看可不可以定义空集合
setvar = {}print(setvar,type(setvar))打印结果报错显然这样是不可以定义空集合的，接下来让我们看看如何定义一个空集合？
setvar = set()print(setvar,type(setvar))打印返回集合类型定义空集合只需要set+（）只有这一种方法可以创建空集合
总结：
6.字典类型（dict）'''
键值对存储的数据
dictvar = {键1：值1,键2：值2,......}
3.6版本之前，完全无序
3.6版本之后，存储的时候，保留了字典定义的字面顺序，在获取内存中的数据时重新按照字面顺序做了排序，所以看起来有序，实际上存储时还是无序。
'''
接下来我们创建一个字典
dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove","support":"吃饱饱_嘴里种水稻"}print(dictvar,type(dictvar))获取字典中的值
dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove","support":"吃饱饱_嘴里种水稻"}res = dictvar["middle"]print(res)修改字典中的值
dictvar["top"] = "the boy"print(dictvar)定义空字典
dictvar = {}print(dictvar,type(dictvar))重要：set和dict 的注意点
'''
字典的键和集合的值有数据类型上面的要求：
（允许的类型范围）不可变的数据类型：Number str tuple
（不允许的类型）可变的数据类型：list set dict
字典的键有要求值没有要求
字典的值可以任意换掉，但是键不可以。键就相当于一个人的身份证号
哈希算法的提出目的是让数据尽量均匀的在内存当中分配，以减少哈希碰撞，提升储存分配的效率;哈希算法一定是无序的散列，所以集合和字典都是无序的
'''
字典允许的类型范围
dictvar = {1:"abc",4.89:111,3+90j:666,False:333,"王文":"你好帅啊，我好喜欢哦,没毛病",(1,2,3,4,5,6):9999}print(dictvar)集合允许的内容
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}print(setvar)哈希算法定义:
把不可变的任意长度值计算成固定长度的唯一值,这个值可正可负,可大可小,但长度固定
该算法叫哈希算法(散列算法)，这个固定长度值叫哈希值(散列值)
特点:
1.计算出来的值长度固定且该值唯一
2.该字符串是密文，且加密过程不可逆

用哈希计算得到一个字符串的用意？
例如：比对两个文件的内容是否一致？
例如：比对输入的密码和数据库存储的密码是否一致

字典的键和集合中的值都是唯一值,不可重复:
为了保证数据的唯一性，
用哈希算法加密字典的键得到一个字符串。
用哈希算法加密集合的值得到一个字符串。
如果重复，他们都是后面的替换前面的。自动去重
版本:
3.6版本之前都是字典和集合都是无序的
3.6版本之后,把字典的字面顺序记录下来，当从内存拿数据的时候，
根据字面顺序重新排序，所以看起来像有序,但本质上无序

可哈希的数据(不可变的数据)：Number(int float bool complex) str tuple
不可哈希的数据 (可变的数据)： list set dict
缓存机制  在同一文件中，变量的缓存机制（仅针对3.6版本）
-->Number 部分
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，非负数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
4.复数在实数+虚数这样的结构中永不相同(只有正虚数的情况例外)
-->容器类型部分
5.字符串和空元组相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
强制类型的转换Number 类型的强制转换（int float complex bool）
（1）int 强制把数据变成整型
可以转换的数据类型： int float bool 纯数字字符串
var1 = 13var2 = 5.67var3= Truevar4 = "123456"var5 = "123abc"var6 = 3+5jres = int(var2)res = int(var3) # True=> 1res = int(False)# False => 0res = int(var4)# res = int(var5) error# res = int(var6) errorprint(res , type(res))（2）float 强制把数据变成浮点型可以转换的数据类型： int float bool 纯数字字符串
res = float(var1)res = float(var3) # True=> 1.0res = float(False)# False => 0.0res = float(var4) # 123456.0 print(res , type(res))（3）complex 强制把数据变成复数可以转换的数据类型：int float bool 纯数字字符串 complex
res = complex(var1) # 添加0j 表达复数res = complex(var2)res = complex(var3)# True => 1+0jres = complex(False) # False => 0jres = complex(var4)# 123456+0jprint(res , type(res))（4）bool 强制把数据类型变成布尔型可以转换的类型：布尔可以强转一切数据类型
布尔型为假的十种情况：0 , 0.0 , False , 0j '' [] () set() {} None
res = bool(None)print(res , type(res))
初始化变量时,不清楚用什么值,无脑写上None
a =Noneb =None