python基础

基础数据类型

1.数字类型（int  float bool complex）

(1)int 整数（正整数   0   负整数）

type 获取值的类型

res = =type(invar)
print(res)

id 获取值的地址

res = id(intvar)
print(res)

 二进制整形

intvar = 0b110
print(intvar)
print(type(intvar))
print(id(intvar))

八进制整形

intvar = 0o127
print(intvar)
print(type(intvar))
print(id(intvar))

十六进制

intvar = 0xff
promt(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 = Ture
print(boolvar,type(boolvar))

(4) complex 复数类型

'''
3 + 4j
实数+虚数
实数：3
虚数4j
j ： 如果有一个数他都平方等于-1，那么这个数就是j，科学家认为有，表达一个高精度的类型
'''
表达方式1
complexvar1 = 3 + 4j
complexvar2 = -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 = 13
var2 = 5.67
var3  = True
var4 = "123456"
var5 = "123abc"
var6 = 3+5j

res = int(var2)
res = int(var3) # True  => 1
res = int(False)# False => 0
res = int(var4)
# res = int(var5) error
# res = int(var6) error
print(res , type(res))

（2）float 强制把数据变成浮点型

可以转换的数据类型： int float bool 纯数字字符串

res = float(var1)
res = float(var3) # True  => 1.0
res = float(False)# False => 0.0
res = 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+0j
res = complex(False) # False => 0j
res = complex(var4)  # 123456+0j
print(res , type(res))

 

（4）bool  强制把数据类型变成布尔型

可以转换的类型： 布尔可以强转一切数据类型

布尔型为假的十种情况：0 , 0.0 , False , 0j '' [] () set() {} None

res = bool(None)
print(res , type(res))

初始化变量时,不清楚用什么值,无脑写上None

a =None
b =None

默认转换成当前数据类型的一个值 int() float() complex() bool()

res = bool() 
print(res , type(res))

额外的扩展

strvar = "123"
strvar = "3.134"
strvar = "5+3j"
# res = int(strvar)
# print(res,type(res))

# res = float(strvar)
# print(res,type(res))

# res = complex(strvar)
# print(    res,type(res)    )

 

Number 自动类型转换（int float complex bool）

注意:低精度默认向高精度进行转换
bool--> int --> float --> complex

# bool + int
res = True + 100
print(res ,type(res)) # 1 + 100 => 101

# bool + float
res = True  + 344.565 # 1.0 + 344.565 => 345.565
print(res ,type(res)) 

# bool + complex
res = True + 7 - 90j  #  1 + 0j + 7 - 90j => 8 - 90j
print(res ,type(res)) 

# int + float
res = 5 + 7.88 # 5.0 + 7.88 => 12.88
print(res ,type(res)) 

# int + complex
res = 5 + 6 + 8j # 5 + 0j   6 + 8j => 11 + 8j
print(res ,type(res)) 

# float + complex 
res = 5.66 + 9.1 -90j # 5.66 + 0j + 9.1 -90j => 14.76-90j
print(res ,type(res)) 

'''
小数的精度损耗 (小数后面一般有时截取15~18位,但是不完全,存在精度损耗)
"""不要用小数作比较,咬不准"""
print(0.1 + 0.2 == 0.3)
print(5.1 + 5.9 == 11.0)
0.0999999999999999
'''

容器类型的强制转换(str list tuple set dict)

var1 = "我爱你,文哥哥"
var2 = [1,2,3]
var3 = (4,4,5)
var4 = {"陈璐","上朝气","刘子涛","合理"}
var5 = {"cl":"文质彬彬,斯文败类","szq":"学霸","lzt":"篮球少年","hl":"武大高手"}
var6 = 90
var7 = True

str 强制转换成字符串

可以转换的类型: 所有的数据类型都可以转换, 在当前的数据类型两边套上引号

res = str(var2) 
res = str(var3)
res = str(var4)
res = str(var5)
res = str(var6)
res = str(var7)
print(res ,type(res))
# repr 不转移字符原型化输出字符串
print(repr(res))

 

list 强制转换成列表

如果是字符串：把字符串中的每个元素单独拿出来，作为列表中的新元素

如果是字典：只保留字典中的键

如果是其他容器数据：就是单纯的在元数据类型的两年换上[ ] 括号

res = list(var1)
res = list(var3)
res = list(var4)
# 字典: 只获取字典得键,忽略掉值
res = list(var5)
# res = list(var6) error 只能是容器间的互转
print(res ,type(res))

tuple 强制转换成元组

如果是字符串：把字符串中的每个元素单独拿出来，作为元组中的新元素

如果是字典： 只保留字典中的键

如果是其他容器数据：就是单纯的在原数据类型的两边换上( ) 括号

res = tuple(var1)
res = tuple(var2)
res = tuple(var4)
res = tuple(var5)
print(res ,type(res))

 

set 强制转换成集合

如果是字符串：把字符串中的每个元素单独拿出来，作为集合中的新元素

如果是字典   ：只保留字典中的键

如果是其他容器数据：就是单纯的在元数据类型的两边换上{}括号

res = set(var1)
res = set(var2)
res = set(var5)
print(res ,type(res))

 

dict 字典类型的强制转换

要求：必须是等长的二级容器,并且里面的元素个数是2个;外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典; 

1.外层是列表,里层是列表或者元组

lst = [ ["a",1] , ("b",2) ]
dic = dict(lst)
print(dic , type(dic)) # {'a': 1, 'b': 2} <class 'dict'>

2.外层是元组,里层是列表或者元组

tup = ( ["a",1] , ("b",2) )
dic = dict(lst)
print(dic , type(dic))

3.外层是集合,里层是元组

setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))

 

例外1:外层是列表/元组,里层放集合

可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用

lst = [ ["a",1] , {"b","250"} ]
dic = dict(lst)
print(dic)

 

例外2:外层是列表/元组,里层放字符串

字符串长度只能是2位,有极大的局限性,不推荐使用

lst = ["a1","b2"]
# lst = ["a11","b22"] error 
# dic = dict(lst)
# print(dic)

 

过滤掉列表中所有重复元素的方法

讲列表转换成集合的数据类型，在转换回字典，因为集合有去重功能

lst = [1,222,3,3,3,44,88,999,77,88,1]
res = set(lst)
print(res)
# 在把当前的集合转换成原来的列表
res2 = list(res)
print(res2)

 

默认不加任何值,转换成该数据类型的空值 str() list() tuple() set() dict()

res = dict()
print(res )
print(type(res))

 

二级容器 ( list tuple set dict )

二级列表

lst = [1,2,3,[4,5,6]]

二级元组

tup = (1,2,(10,11))

二级集合

setvar = {1,2,("a","b")}

二级字典

dic = {"a":1,"b":{"c":10}}
print(dic["b"]["c"])

 

四级容器

如何获取bingo？

container = [1,2,3,(4,5,6,{"a":1,"b":[11,"bingo"]})]
# (4,5,6,{"a":1,"b":[11,"bingo"]})
res1 = container[-1]
print(res1)

# {'a': 1, 'b': [11, 'bingo']}
res2 = res1[-1]
print(res2)

# [11, 'bingo']
res3 = res2["b"]
print(res3)

# bingo
res4 = res3[-1]
print(res4)

# 一步简写
res = container[-1][-1]["b"][-1]
print(res)

 

等长的二级容器

外面是容器,里面的元素也是容器,且元素个数相同

判断类型 isinstance

使用方法一：isinstance(数据，类型)

该数据是这个类型，返回True 反之，返回False

类型：int float complex bool str list tuple set dict

 

使用方法二： isinstance (数据，(类型1，类型2，类型3...))

如果该数据在所对应的类型元组当做，返回True，反之，返回False

 

使用方法一：

n = 123
res = isinstance(n,int)
prinr(res)

n = [1,2,3]
res = isinstance(n,list)
res = isinstance(n,tuple)
print(res)

 

使用方法二：

使用方法二
n = "1233"
res = isinstance(n,(list,tuple,str,set))
print(res)

n = {"a":1}
res = isinstance(n,(list,tuple,str,set))
print(res)

 

算数 比较

（1）算数运算符：+ - * /  // % **

+

var1 = 7
var2 = 90
res = var1 + var2
print(res)

 

-

var1 = 7
var2 = 90
res = var1 - var2
print(res)

 

 *

var1 = 7
var2 = 10
res = var1 * var2
print(res)

 /  （结果永远都为小数）

var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res))

// 地板除

被除数 ÷ 除数  = 商

注意点：如果被除数或者除数是小数，那么得到正常结果之后，数值后面带上.0变成小数

var1 = 10.0
var2 = 3.0
# var2 = 3.0
res = var1 // var2
print(res)

 % 取余

var1 = 7
var2 = 4
res = var1 % var2
res = -7 % 4  # -3 + 4 = 1
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7   # 4
res = 81 % -7  # -3
res = -81 % 7  # 3
res = -81 % -7 # -4
print(res)

**幂运算

res = 2 ** 3
print(res)

 

（2）比较运算符：> , < , >= , >= , == , !=  

比较运算符的结果要么是True，要么是False 只有两个值

res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9 
print(res)

 

（3）赋值运算符： =  +=  -=  *=  /=  //=  %=  **=

= 赋值运算符 将右侧的值赋值给左侧变量

a = 5 <= 3
print(a)


var1 = 10
var2 = 5

+= 

"""var1 = var1 + var2"""
# var1 += var2
# print(var1)

-=

"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)

%=

"""var1 = var1 % var2"""
var1 %= var2
print(var1)

（4）成员运算符：in 和 not in （针对于容器型数据）

①字符串判断时，必须是连续的片段

strvar = "今天天气要下雨,赶紧回家收衣服"

res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)

②针对于列表，元组，集合

container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)

③针对于字典（判断的是字典的键，不是值）

container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)

（5）身份运算符 is 和 is not （检测两个数据在内存当中是否是同一个值）

①整型 - 5 ~ 正无穷

var1 = 100
var2 = 100
print(var1 is var2)

②浮点型 非负数

var1 = -9.1
var2 = -9.1
print(var1 is var2)

③ bool 相同即可

var1 = True
var2 = True
print(var1 is var2)

④complex 在实数+虚数不相同（只有虚数的情况下例外）

var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)

⑥容器：相同字符串，空元组相同即可 剩下的所有容器都不相同

container1 = ()
container2 = ()
print(container1 is not container2)

container1 = "你"
container2 = "你"
print(container1 is not container2)

container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

（6）逻辑运算符：and or not

① and 逻辑与

一真则真，一假则假

res = True and True    # True
res = True and False   # False
res = False and True   # False
res = False and False  # False
print(res)

② or  逻辑或

一真则真，全假则假

res = True or True    # True
res = False or True   # True
res = True or False   # True 
res = False or False  # False
print(res)

 

③ not  逻辑非

res = not True
res = not False
print(res)

 

 

④逻辑短路

 无论后面的表达式是True 还是False 都已经无法改变最后的结果，那么直接短路，后面的代码不执行；

(1) True or print("程序执行了~ 1111")

(2) False ande print("程序执行了~2222")

True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False

 

计算规律：

先脑补计算当前表达式的布尔值是True还是False，如果出现了True or 表达式 或者False and 表达式的情况，直接返回牵着，后面代码不执行，如果没有出现短路效果，直接返回后者

res = 5 and 6  # 6

'''

True and True => True

True and False => False

'''

接下来看一段代码

 

res = 5 or 6  # 5
res = 0 and 999
res = 0 or "abc"
print(res)

 

逻辑运算符的优先级：

优先级从高到低：() > not > and > or 

小练习：

res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)

 

 

not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True

print(res)

（7）位运算符：& |  ^ <<   >>  ~

① & 按位与

var1 = 19
var2 = 15

res = var1 & var2
print(res)

#结果是这么来的：
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""

② | 按位或

var1 = 19
var2 = 15

res = var1 |var2
print(res)

结果是这么来的：
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""

③ ^ 按位异或

量遏制不相同 => True  反之返回False

var1 = 19
var2 = 15

res = var1 ^ var2
print(res)

结果是这么来的：
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""

④ << 左移（想当于乘法）

这个数乘以2的n次幂

res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)

结果是这么来的：
"""

000 ... 101  => 5
000 .. 1010  => 10
000 ..10100  => 20
000 .101000  => 40
"""

⑤ >> 右移 （相当于除法）

这个数地板除2的n次幂

res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
print(res)

结果是这么来的:

"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""

⑥ ~ 按位非（针对于补码进行操作，按位取反，包含每一位）

 -（n+1）

练习1：

# res = ~22
res = ~19
print(res)

结果是这么来的："""

原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011

补码:   000 ... 10011
按位非: 111 ... 01100

给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""


练习2

res = ~-19
print(res)

结果是这么来的:

"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101

补码:   111 ... 01101
按位非: 000 ... 10010

给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 19
"""

 

总结：

个别运算符：

　　运算符优县级最高的：**

　　运算符优先级最低的：=

 

　　（） 可以提升优先级

一元运算符 > 二元运算符（优先级）

　　一元运算符：同一时间，操作一个值 ~  -

　　二元运算符：同一时间，操作一个值 + - * / ……

同一种类运算符：

　　算数运算符：乘除 > 加减

　　逻辑运算符：() > not > and > or

　　位运算符： (<<  >>)   > &  >  ^  >  |

整体排序：

　　算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符、

　　赋值运算符用来做收尾

 

 小练习

res = 5+5 << 6 // 3 is 40 and False
"""
res = 10 << 2 is 40 and False
res = 40 is 40 and False
res = True and False
res = False
"""
print(res)

# 用括号提升下优先级
res = (5+5) << (6//3) is 40 and False

 

代码块（以冒号作为开始，用缩进来划分相同的作用于，这个整体是代码块）

作用域：作用的范围

if 10 == 11:
    print(1)
    print(2)
    print(3)
print(4)

 

# 缩进：要么全都使用/t Tab  要么全都是使用4个空格 来表达相同的作用域，不能混在一起；

if 10 == 10:
    print(1)
    print(2)

 

其他语言的写法（了解）

if(10 == 10){
    print(1)
                    print(2)
                                                                                                    print(3)
}                                                        

 

 

流程控制

流程：代码执行的过程

控制：对代码执行过程中的把控

 

三大结构：

（1）顺序结构：默认代码从上到下，依次执行

（2）分支结构：单项分支 双向分支 多项分支 巢状分支

（3）循环结构：while / for

单项分支

if 条件表达式：

　　code1

　　code2

当条件表达式成立，返回True，执行对应的代码块

zhiye = "程序员"
if zhiye == "程序员":
    print("拿高薪")
    print("钱多,话少,死的早")
    print("发量日渐稀少")

 

双向分支（二选一）

if条件表达式：

　　code1  ...

else：

　　code2...

如果条件表达式成立，返回True，执行if这个区间的代码块

如果条件表达式不成立，返回False，执行else这个区间的代码块

if  分支的代码快啊也叫做镇区间

else 分支的代码块也叫做假区间

 

zhiye = "美团外卖骑手"
zhiye = "律师"
if zhiye == "美团外卖骑手":
    print("打他")
    print("骂他")
    print("喂他辣椒水")
else:
    print("给你一朵红花")

 

input 等待用户输入字符串（注意：结果一定是字符串）

name = input("你好~ 你妈贵姓：")
print(name,type(name))

 

模拟网站登陆

如果admin = Sam  密码：password = 111 显示登陆成，否者显示登陆失败

admin = input("请输入您的账号：")
password = input("请输入您的密码：")
if admin == "Sam" and password == "111":
    promt("登陆成功")
else：
    print("登陆失败")

 

多项分支(多选一)

"""

if 条件表达式1:

　　code1

elif 条件表达式2:

　　code2

elif 条件表达式3:

　　code3

else:

　　code4

如果条件表达式1成立,执行对应的分支code1,反之判断条件表达式2是否成立

如果条件表达式2成立,执行对应的分支code2,反之判断条件表达式3是否成立

如果条件表达式3成立,执行对应的分支code3,如果不成立,直接走ekse分支,到此程序执行完毕

elif 可以是0个   或者  多个

else 可以是0个 或者 一个

"""

youqian = False
youfang = False
youche = False
if youqian == True:
    print("说明这个人很有实力")
elif youfang == True:
    print("能交给朋友么")
elif youche == True:
    print("开了雅迪艾玛调动车,我们碰一碰吧")    
else:
    print("你还是去做美团骑手吧")

print("<=======================>")

 巢状分支

"""单项分支,双向分支,多项分支的互相嵌套组合"""

youqian = True
youfang = True
youche = True
youyanzhi = True
youtili = False

if youqian == True:
    if youfang == True:
        if youche == True:
            if youyanzhi == True:
                if youtili == True:
                    print("我要嫁给你~")
                else:
                    print("你去吃点大腰子再来~")
            else:    
                print("你去一下泰国+韩国,整整容")
else:
    print("你是个好人呐~")

 

小练习

#height
#女生找对象
# 男生在1米~1.5米之间 小强 你在哪里?
# 男生在1.5~1.7米之间 没有安全感~
# 男生 1.7~ 1.8米之间 帅哥 留个电话
# 男生 1.8~2米之间 帅哥 你建议多一个女朋友吗

 

# 通用写法
height = float(input("请输入您的身高:"))
if 1 <= height and height < 1.5:
    print("小强 你在哪里?")
elif 1.5 <= height and height < 1.7:
    print("没有安全感~")
elif 1.7 <= height and height < 1.8:
    print("帅哥 留个电话")
elif 1.8 <= height and height < 2:
    print("你建议多一个女朋友吗")
else:
    print("抱歉,没有合适的选项")

快捷键用法:
tab 向右缩进
shift + tab 向左缩进

循环结构

特点:减少冗余代码,提升执行效率

语法:

while 条件表达式:

　　code1

 

(1)初始化一个变量

(2)写上循环的条件

(3)自增自减的值

 

打印1~100

# (1) 初始化一个变量
i = 1
# (2) 写上循环的条件
while i <= 100:

    # (4) 写上循环的逻辑
    print(i)

    # (3) 自增自减的值
    i += 1 # i = i + 1

"""
代码解析:
第一次循环
i = 1  i<=100 判断为真,执行循环体 print(1)
i += 1 i => 2 
第二次循环
代码回到17行,重新进行条件判定 
i = 2  i<=100 判断为真,执行循环体 print(2)
i += 1 i => 3
第三次循环
代码回到17行,重新进行条件判定 
i = 3  i<=100 判断为真,执行循环体 print(3)
i += 1 i => 4

....
以此类推 

直到i = 101  i <= 100 判断为假,不执行循环体,到此循环结束...
1 ~ 100
"""

 

1~100的累加和

# (1) 初始化一个变量
i = 1
total = 0

# (2) 写上循环的条件
while i <= 100 :
    # (4) 写上自定义的逻辑
    total += i
    # (3) 自增自减的值
    i += 1
print(total)


"""
代码解析:
第一次循环
i = 1 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1
i += 1  => i = 2

第二次循环
i = 2 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1 + 2
i += 1  => i = 3

第三次循环
i = 3 i <= 100 判定为真True 执行循环体 total += i => total = total + i => 0 + 1 + 2 + 3 
i += 1  => i = 4

...
依次类推

当i = 101 101 <= 100 判定为假False 不执行循环体,到此,循环结束..

total += i => total + i => 0 + 1 + 2 + 3 + 4 + .... + 100 => 5050

"""

死循环

"""

while True:

　　print(1)

"""

 

用死循环的方法实现1~100的累加和

i = 1
total = 0
sign = True
while sign:
    total += i
    i+=1
    
    # 判断i是否加到了101 , 不参与循环
    if i == 101:
        # 终止循环
        sign = False
print(total) #1 ~ 100 = 5050

 

单向循环的练习

(1)打印 一行是个小星星* help(print)

# help 查看某个方法的文档

help(print)

"""
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
# print("*",end='')
"""

如果用上面的方法不仅代码量多 而且太蠢了 接下来我们用while 循环

i = 0
while i<10:    
    # end='' 打印时,尾部默认不加换行
    print("*",end='')    
    i += 1
# 默认换行
# print()

(2)通过打印一个变量的形式,展现一行十个小星星

print("<======>")
i = 0
strvar = ""
while i < 10:
    # 写上循环的逻辑
    strvar += "*" # strvar = strvar + "*"
    i +=1
print(strvar)


过程:
"""
strvar += "*" => strvar = "*"
strvar += "*" => strvar = "*" + "*"  = "**"
strvar += "*" => strvar = "**" + "*" = "***"
...
strvar += "*" => strvar = "********" + "*" = "*********"
"""

(3)一行十个换色的星星★☆★☆★☆★☆★☆

方法一:

i = 0
while i < 5:
    print("★☆",end="")
    i+=1

方法二:

i = 0
while i < 10:
    if i % 2 == 0 :
        print("★",end="")
    else:
        print("☆",end="")
    i+=1

方法三:

i = 0
strvar = ""
while i < 10:
    if i % 2 == 0 :
        strvar += "★"
    else:
        strvar += "☆"
    i+=1
print(strvar)

 

***公式: 任意数 和 n 进行取余,余数的范围: 0 ~ (n-1)***
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
3 % 2 = 1
被除数 % 2 => 0 或者 1

0 % 5 = 0 
1 % 5 = 1
2 % 5 = 2
3 % 5 = 3
4 % 5 = 4
5 % 5 = 0 
6 % 5 = 1
7 % 5 = 2
被除数 % 5 => 0 或者 1,2,3,4

 

(4)用一个循环,打印十行十列小星星

"""

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

★★★★★★★★★★

"""

方法一:

i = 0 
while i < 100:
    
    # 逻辑写在这里
    print("*" , end="")
    # 打印换行 (在9 19 29 .. 99 )
    if i % 10 == 9:
        print()
    i += 1 

 

"""
0123456789
**********
10111213141516171819
**********
20212223242526272829
**********

...
90919293949596979899
**********
9 19 29 39 49 59 69 79 89 99
9 % 10 = 9
19 % 10 = 9
29 % 10 = 9
...
99 % 10 = 9

"""

方法二:

i = 1
while i <= 100:
    
    # 逻辑写在这里
    print("*" , end="")
    # 打印换行 (在9 19 29 .. 99 )
    if i % 10 == 0:
        print()
    i += 1 

"""
12345678910
**********
11121314151617181920
**********
21222324252627282930
**********

...
919293949596979899100
**********
10 20 30 ... 100
"""

(5)一个循环实现一十行十列,格列换色的小星星

"""
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
"""

i = 0 
while i < 100:
    
    # (1)打印星星
    if i % 2 == 0 :
        print("★",end="")
    else:
        print("☆",end="")
    
    # (2)打印换行 (在9 19 29 .. 99 )
    if i % 10 == 9:
        print()
    
    i += 1 

(6)一个循环实现十行十列,隔行换色的小星星

"""

★★★★★★★★★★

☆☆☆☆☆☆☆☆☆☆

★★★★★★★★★★

☆☆☆☆☆☆☆☆☆☆

★★★★★★★★★★

☆☆☆☆☆☆☆☆☆☆

★★★★★★★★★★

☆☆☆☆☆☆☆☆☆☆

★★★★★★★★★★

☆☆☆☆☆☆☆☆☆☆

"""

公式:任意数和n进行底板处,会出现n个相同的数 

0 // 10 = 0
1 // 10 = 0
2 // 10 = 0
..
9 // 10 = 0
0 ~ 9 // 10 => 0 (10个相同的0)

10 // 10 = 1
11 // 10 = 1
12 // 10 = 1
...
19 // 10 = 1
10 ~ 19 // 10 => 1 (10个相同的1)

.... 以此类推
20 ~ 29 // 10 => 2 (10个相同的2)
30 ~ 39 // 10 => 3 (10个相同的3)
40 ~ 49 // 10 => 4 (10个相同的4)
...
90 ~ 99 // 10 => 9 (10个相同的9)

0~ 100 会出现10个相同的0,1,2 , 3 ... 9 

0 // 3 0
1 // 3 0
2 // 3 0
3 // 3 1
4 // 3 1
5 // 3 1 
"""

方法一:

i = 0 
while i < 100:
    
    # (1)打印星星
    if i // 10 % 2 == 0:
        print("★",end="")
    else:
        print("☆",end="")

    # (2)打印换行 (在9 19 29 .. 99 )
    if i % 10 == 9:
        print()
    
    i += 1 

方法二:

print("<=================>")
i = 10
while i < 110:
    # 打印星星 
    num = int(str(i)[-2])
    if num % 2 == 0 :
        print("★",end="")
    else:
        print("☆",end="")
    # 打印换行
    if i % 10 == 9:
        print()
    i+=1




#解析:
"""
10 ~ 100 101 102 103 110...

10 ~ 19 => 1
20 ~ 29 => 2
30 ~ 39 => 3
90 ~ 99 => 9
100 ~ 109 => 0
"""

双向循环练习

1.用两个循环完成十行十列的小星星

j = 0 
while j < 10:

    # 打印星星
    i = 0
    while i < 10:
        print("*",end="")
        i+=1
    
    # 打印换行
    print()

    j += 1

2.用两个循环完成十行十列隔列换色的小星星

"""
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
☆★☆★☆★☆★☆★
"""

i = 0
while i < 10:
    # 打印一行黑白相间的星星
    j = 0
    while j < 10:
        if j % 2 == 0:
            print("☆",end="")
        else:
            print("★",end="")
        j +=1

    # 打印换行
    print()    
    i+=1

3.用俩两个循环完成十行十列隔行换色的小星星

"""
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
"""

"""
外层的循环i动的慢
内层的循环j动的快
外层的i动一次, 内层的循环动10次

"""
i = 0
while i < 10 :
    j = 0
    while j < 10:
        if i % 2 == 0:
            print("☆",end="")
        else:
            print("★",end="")
            
        j +=1
    print()
    i +=1

4.99乘法表

# 方向一
i = 1
while i <= 9:
    
    # 打印对应的表达式
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    
    # 打印换行
    print()
    
    i +=1



# 方向二
i = 9
while i >= 1:

    # 打印对应的表达式
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    
    # 打印换行
    print()

    i -= 1
print("<====================>")
# 方向三
i = 1
while i <= 9 :
    kongge = 9 - i
    # 打印空格
    while kongge > 0:
        print("       ",end="")
        kongge -= 1  

    # 打印表达式
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    
    # 换行
    print()
    i +=1

print("<===============>")
# 方向四
i = 9
while i >= 1 :
    kongge = 9 - i
    # 打印空格
    while kongge > 0:
        print("       ",end="")
        kongge -= 1  

    # 打印表达式
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    
    # 打印换行
    print()
    i -=1

求吉利数字 100 ~ 999 之间 找 111 222 333 123  456 654 321 ...

"""
// 可以获取一个数高位
%  可以获取一个数低位
baiwei = 345 // 100
shiwei = 345 // 10 % 10
gewei  = 345 % 10
print(gewei)
"""

# 方法一
i = 100
while i <= 999:
    baiwei = i // 100
    shiwei = i // 10 % 10
    gewei = i % 10

    if shiwei == gewei  and shiwei == baiwei :
        print(i)
    # 123
    elif shiwei == gewei - 1 and shiwei == baiwei + 1:
        print(i)
    # 987
    elif shiwei == gewei + 1 and shiwei == baiwei - 1:
        print(i)
    i +=1

# 方法二
print("<====>")
i = 100
while i <= 999:
    strvar = str(i)
    # print(strvar, type(strvar))
    gewei = int(strvar[-1])
    shiwei = int(strvar[1])
    baiwei = int(strvar[0])
    if shiwei == gewei  and shiwei == baiwei :
        print(i)
    # 123
    elif shiwei == gewei - 1 and shiwei == baiwei + 1:
        print(i)
    # 987
    elif shiwei == gewei + 1 and shiwei == baiwei - 1:
        print(i)
    
    i +=1

# 方法三
print("<====>")
i = 100
while i <= 999:
    strvar = str(i)
    # print(strvar, type(strvar))
    gewei = int(strvar[-1])
    shiwei = int(strvar[1])
    baiwei = int(strvar[0])

    if 2 * shiwei == gewei + baiwei and (shiwei == gewei + 1 or shiwei == gewei -1 ):
        print(i)
    elif gewei == shiwei and shiwei == baiwei:
        print(i)
    
    i +=1

百钱买百鸡

"""
穷举法:把数据拿出来一个一个试
x = [1,2]
y = [3,4]
z = [5,6]
x+y+z = 10
1 + 3 + 5 = 9
1 + 3 + 6 = 10 bingo
1 + 4 + 5 = 10 bingo
1 + 4 + 6 = 11
2 + 3 + 5 = 10 bingo
2 + 3 + 6 = 11
2 + 4 + 5 = 11
2 + 4 + 6 = 12
"""

"""
公鸡 : x  母鸡 : y  小鸡: z
鸡的数量:x + y + z = 100
鸡的价格:5 * x + 3 * y + 1/3*z = 100   
"""

x = 0
while x <= 20:
    
    y = 0
    while y <= 33:
        
        z = 0
        while z <= 100:
            
            if x+y+z == 100 and 5*x + 3 * y + 1/3*z == 100 :
                print(x,y,z)
            z += 1    
        
        y +=1
    
    x += 1

 

字符串的相关操作

（1）字符串的拼接 +

str1 = "赵沈阳,"
str2 = "so strong"
res = str1 + str2
res = "赵沈阳," + "so strong"
print(res)

# res = res + ",旁边的同学很喜欢他~"
res += ",旁边的同学很喜欢他~"
print(res)

（2）字符串的重复 * 

strvar = "重要的事情说三遍~"
res = strvar * 3
print(res

（3）字符串的跨行拼接

str1 = "kskfjskjfklsjfklasdjklfjaskldjfaskljfklasjdfklasjdklfjaskldfjaskldjflasjfsf" \
"1122334"
print(str1)

（4）字符串的索引

#            0 1 2 3 4 5
strvar = "赵世超真帅呀"
#           -6-5-4-3-2-1
print(strvar[1])

（5）字符串的切片

语法 => 字符串[::] 完整格式：[开始索引:结束索引:间隔值]
(1) [开始索引:] 从开始索引截取到字符串的最后
(2) [:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3) [开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4) [开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
(5) [:]或[::] 截取所有字符串

strvar = "王文是这个宇宙当中,最完美,无暇,善良,漂亮,英俊,帅气,潇洒,风流倜傥的神秘男孩"
# (1)[开始索引:]  从开始索引截取到字符串的最后
res = strvar[3:]
print(res)
    
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
"""4这个最大值本身获取不到,要获取到4之前的那一个数据 : 取头舍尾"""
res = strvar[:5]
print(res)
    
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = strvar[10:16]
print(res)

# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符

# 从左向右截取
res = strvar[::3]
# 0 3 6 9 12 15 ... 
print(res)

# 从右向左截取
res = strvar[::-1]
# -1 -2 -3 -4 -5 -6 .... 
print(res)

res = strvar[-3:-10:-2]
# -3 -5 -7 -9   秘的倜风
print(res)

"""从左到右截,间隔值为正值,反过来,间隔值是负值,才能保证截取到数据"""
"""
res = strvar[-3:-10:10] # 错误的逻辑
print(res)
res = strvar[1:10]
print(res)
"""

关键字的使用 pass break continue

pass 过 (代码块中的占位符)

if 20 == 20:
    pass
    
while True:
    pass

 break 终止当前循环 (只能用在循环之中)

# 1 ~ 10 遇到5终止循环
i = 1
while i <= 10:
    print(i)
    if i == 5:
        break
    i +=1
    
    
i = 1
while i <= 3:
    
    j = 1
    while j <=3:
        if j == 2:
            break
        print(i,j)
        j+=1

    i +=1
# 1 1
# 2 1 
# 3 1
"""
if 5 == 5: error
    break
"""

continue 跳过当前循环,从下一次循环开始

# 打印 1 ~ 10 跳过5
i = 1
while i <= 10:
if i == 5:
# 在跳过之前,因为会终止执行后面的代码,从下一次循环开始
# 为了避免死循环,手动加1
i += 1
continue
print(i)
i +=1

# 1 ~ 100 打印所有不含有4的数字
# 方法一
print("<============>")
i = 1
while i <= 100:
strvar = str(i)
# print(strvar)
if "4" in strvar:
i += 1
continue
print(i)
i +=1


# 方法二
print("<============>")
i = 1
while i <= 100:
if i // 10 == 4 or i % 10 == 4:
i+=1
continue
print(i)
i+=1

 

 

for循环

遍历 循环 迭代 ，把容器中的元素一个一个获取出来

while 循环在遍历数据是的局限性

lst = [1,2,3,4,5]  # ok
i = 0
while i < len(lst):
    print(lst[i])
    i+=1
    
setvar = {"a","b","c"} # not ok
i = 0
while i < len(setvar):
    print(setvar[i])
    i+=1

for循环的基本语法

Iterable 可迭代性数据： 1.容器类型数据 2.range对象 3. 迭代器

for 变量 in Iterable：

　　code1

 

# 字符串
container = "北京和深圳温差大概20多度"
# 列表
container = [1,2,3,4,4,5]
# 元组
container = ("孙开洗","孙健","孙悟空")
# 集合 
container = {"陈璐","曹静怡","王志国","邓鹏","合力"}
# 字典
container = {"cl":"风流倜傥","cjy":"拳击选手","wzg":"寻花问柳","dp":"帅气,祖国的栋梁","hl":"你是个好人"}

遍历数据

for i in container:
    print(i)

1.遍历不等长多级容器

container = [1,2,3,4,("嗄","234",{"马春配","李虎凌","刘子涛"})]
for i in container:
    # 判断当前元素是否是容器,如果是,进行二次遍历,如果不是,直接打印
    if isinstance(i,tuple):
        # ("嗄","234",{"马春配","李虎凌","刘子涛"})
        for j in i:
            # 判断当前元素是否是集合,如果是,进行三次遍历,如果不是,直接打印
            if isinstance(j,set):
                # j = {"马春配","李虎凌","刘子涛"}
                for k in j :
                    print(k)
            else:
                print(j)
                
    # 打印数据
    else:
        print(i)

2.遍历不等长多级容器

container = [("刘玉波","历史源","张光旭"), ("上朝气","于朝志"),("韩瑞晓",)]
for i in container:
    for j in i:
        print(j)

3.遍历等长的容器

container = [("马云","小马哥","马春配") , ["王健林","王思聪","王志国"],{"王宝强","马蓉","宋小宝"}]
for a,b,c in container:
    print(a,b,c)

变量的解包

a,b,c = "poi"
a,b = (1,2)
a,b = 1,2
a,b,c = [10,11,12]
a,b = {"林明辉","家率先"}
a,b = {"lmh":"林明辉","jsx":"家率先"}
a,b,c = ("马云","小马哥","马春配")
print(a,b,c)

range对象

range([开始值,]结束值[,步长])，取头舍尾,结束值本身获取不到,获取到它之前的那一个数据

 

# range(一个值)
for i in range(5): # 0 ~ 4
    print(i)

# range(二个值)
for i in range(3,8): # 3 4 5 6 7 
    print(i)

# range(三个值) 正向的从左到右
for i in range(1,11,3): # 1 4 7 10 
    print(i)

# range(三个值) 逆向的从右到左
for i in range(10,0,-1): # 10 9 8 7 ... 1 
    print(i)

总结:

"""
while 一般用于处理复杂的逻辑关系
for   一般用于迭代数据
部分情况下两个循环可以互相转换;
"""

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
        j+=1
    print()    
    i +=1

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%2d " % (i,j,i*j) ,end="" )
    print()

# 打印 1 ~ 10 跳过5
i = 1
while i <= 10:    
    if i == 5:
        i += 1
        continue
    print(i)
    i +=1
    
for i in range(1,11):
    if i == 5:
        continue
    print(i)

 

字符串的格式化format

(1)顺序传参

{}是format中的占位符

strvar = "{}向{}开了一枪,饮蛋而亡".format("赵沈阳","需保障")
print(strvar)

(2)索引传参

strvar = "{1}向{0}开了一枪,饮蛋而亡".format("赵沈阳","需保障")
print(strvar)

(3)关键字传参 

strvar = "{who1}摸了{who2}一下,回头一巴掌".format(who1="王伟",who2="马春妮")
strvar = "{who1}摸了{who2}一下,回头一巴掌".format(who1="马春妮",who2="王伟")
print(strvar)

(4)容器类型数据(列表或元祖)传参

# 方法一
strvar = "{0[0]}摸了{1[1]}一下,嘿嘿一笑,有戏".format(["赵蜂拥","赵世超","杨元涛"] , ("王雨涵","王同培"))
print(strvar)

# 方法二(推荐)
strvar = "{group1[0]}摸了{group2[1]}一下,嘿嘿一笑,有戏".format(group1=["赵蜂拥","赵世超","杨元涛"] , group2 = ("王雨涵","王同培"))
print(strvar)

# 方法三(推荐) 注意一.如果该容器是字典,通过键取值时,不需要加引号  注意二.通过下标取值时,不能使用负号(逆向索引)
strvar = "{group1[zfy]}摸了{group2[-1]}一下,嘿嘿一笑,有戏".format(group1={"zfy":"赵蜂拥","zsc":"赵世超"} , group2 = ("王雨涵","王同培"))
print(strvar)

(5)format的填充符号的使用( ^ > < )

^ 原字符串居中显示
> 原字符串居右显示
< 原字符串居左显示

{who:*^10}
* : 填充的符号
^ : 原字符串居中显示
10: 原字符串长度 + 填充符号的长度 = 10

strvar = "{who:*^10}去长春长生医药公司,{do:>>10},感觉{feel:!<10}".format(who="李亚峰",do="扎疫苗",feel="血槽被掏空")
print(strvar)

(6)进制转换等特殊符号的使用( :d :f :s :, )

:d 整型占位符 (强制要求类型是整型)

strvar = "刘一峰昨天晚上买了{:d}个花露水泡脚".format(9)
print(strvar)

:3d 占3位,不够三位拿空格来补位(原字符串居右)

strvar = "刘一峰昨天晚上买了{:3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:<3d}个花露水泡脚".format(9)
print(strvar)
strvar = "刘一峰昨天晚上买了{:^3d}个花露水泡脚".format(9)
print(strvar)

:f 浮点型占位符 (强制要求类型是浮点型) 默认保留小数6位

strvar = "王雨涵毕业之后的薪资是{:f}".format(9.9)
print(strvar)

:2f 小数点后保留2位,存在四舍五入

strvar = "王雨涵毕业之后的薪资是{:.2f}".format(9.188888)
print(strvar)

:s 字符串占位符

strvar = "{:s}".format("杨元涛真帅")
print(strvar)

:, 金钱占位符

strvar = "{:,}".format(12345678)
print(strvar)

综合案例

strvar = "{:s}开工资{:.2f}元,买了{:d}个兰博基尼".format("孙坚",300000.12345,10)
print(strvar)

 

字符串的相关函数

.capitalize() 字符串首字母大写

strvar = "how are you"
res = strvar.capitalize()
print(res)

.title() 每个单词的首字母大写

strvar = "how old are you"
res = strvar.title()
print(res)

.upper() 将所有字母变成大写

strvar = "How Old Are You"
res = strvar.upper()
print(res)

.lower() 将所有字母变成小写

res = strvar.lower()
print(res)

.swapcase() 大小写互换

strvar = "How old Are You"
res = strvar.swapcase()
print(res)

len 计算字符串的长度

strvar = "python32真热"
res = len(strvar)
print(res)

.count() 统计字符串中某个元素的数量

count(字符,[开始值,结束值])

strvar = "真热真热呀"
# res = strvar.count("真")     # 2
# res = strvar.count("热",2)   # 1
# res = strvar.count("热",2,3) # 只有真这个字符 没有热
print(res)

.find() 查找某个字符串第一次出现的索引位置 (推荐)

find(字符,[开始值,结束值])

strvar = "To be or not to be that is a question"
res = strvar.find("to")
res = strvar.find("be",4)
# 如果find 返回的是 -1 代表没找到
res = strvar.find("be",4,10) # 4 ~ 9
print(res)

.index() 与 find 功能相同 find找不到返回-1,index找不到数据直接报错

res = strvar.index("be",4,10) 
print(res)

.startswith() 判断是否以某个字符或字符串为开头

startswith(字符,[开始值,结束值])
endswith(字符,[开始值,结束值])

strvar = "To be or not to be that is a question"
res = strvar.startswith("To")
res = strvar.startswith("To",10)
print(res)

 

.endswith() 判断是否以某个字符或字符串结尾

res = strvar.endswith("question")
res = strvar.endswith("is",-14,-11) #  is
print(res)

 

is系列

.isupper() 判断字符串是否都是大写字母

strvar = "HOW  A  YOU"
res = strvar.isupper()
print(res)

.islower() 判断字符串是否都是小写字母

strvar = "asdf - as"
res = strvar.islower()
print(res

.isdecimal() 检测字符串是否以数字组成 必须是纯数字

strvar = "abcdefg"
strvar = "2134234.123"
strvar = "2134234"
res = strvar.isdecimal()
print(res)

 

.split() 按某字符将字符串分割成列表(默认字符是空格) ***

strvar = "you can you up no can no bb"
lst = strvar.split()
strvar = "you#can#you#up#no#can#no#bb"
lst = strvar.split("#")
print(lst)

.join()  按某字符将列表拼接成字符串(容器类型都可) ***

lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
strvar = " ".join(lst)
strvar = "#".join(lst)
print(strvar)

.replace() 把字符串的旧字符换成新字符 ***

字符串.replace('旧字符','新字符'[, 限制替换的次数])

strvar = "范冰冰爱不爱我,爱我,不爱我,爱我,不爱我"
res = strvar.replace("不爱我","爱我")
# 选择替换的次数
res = strvar.replace("不爱我","爱我",1)
print(res)

.strip()  默认去掉首尾两边的空白符 ***

空白符 空格 \n \t \r ... 

strvar = "     周润发  "
res = strvar.strip()
print(strvar)
print(res)

.center() 填充字符串,原字符居中 (默认填充空格)

center(字符长度,填充符号)

strvar = "赵世超"
res = strvar.center(10)
# res = strvar.center(10,"*")
print(res)

列表的相关操作

lst1 = ["孟凡伟","康与众"]
lst2 = ["康与众","张宇"]

(1)列表的拼接   (同元组)

res = lst1 + lst2
print(res)

(2)列表的重复   (同元组)

res = lst1 * 3
print(res)

 

(3)列表的切片   (同元组)

语法 => 列表[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到列表的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
(5)[:]或[::] 截取所有列表

(1)[开始索引:]  从开始索引截取到列表的最后

lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]

res =lst[2:]
print(res)

(2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)

res =lst[:3]
print(res)

(3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)

res = lst[3:5]
print(res)

(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值

正向截取

res = lst[::5]
print(res) # 0 5 10

逆向截取

res = lst[::-3] # -1 -4 -7
print(res)

(5)[:]或[::]  截取所有列表

res = lst[:]
res = lst[::]
print(res)

(4)列表的获取   (同元组)

#      0  1   2
lst = [10,20,30]
#     -3  -2 -1
print(lst[-1])

(5)列表的修改   ( 可切片 )

1.改多个值 (如果使用切片进行修改,要求数据必须是Iterable可迭代性数据)

# lst[1:4] = ["孙悟空","猪八戒","白骨精"]
lst[1:4] = "你好"
print(lst)

2.改多个值(带有步长)

带有步长的切片修改,切出几个元素就修改几个元素,数量要一致.

lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]
"""0 3 6 """
lst[::3] = "abc"
# lst[::3] = "ab" error
print(lst)

(6)列表的删除   ( 可切片 )

lst = ["孟凡伟","康与众","张宇","赵沈阳","需保障","梁新宇","沈思雨"]

1.一次删一个

del lst[2]
print(lst)

2.一次删一堆

del lst[1:-1]
print(lst)

3.注意点

res = lst[1:-1]
del res # 删除的是res这个变量 和 列表无关
print(lst)

额外的注意点

tup = (1,2,3,4,[10,11,12])
print(tup[-1])
tup[-1][-1] = 13
print(tup)

 

列表相关的函数

增

append 向列表的末尾添加新的元素

lst = ["赵沈阳"]
lst.append("沈思雨")
print(lst)

insert 在指定索引之前插入元素

lst = ['赵沈阳', '沈思雨']
lst.insert(1,"王伟")
print(lst)

extend 迭代追加所有元素

迭代追加的数据是可迭代性数据(容器类型数据,range对象,迭代器)

lst = ['赵沈阳', '沈思雨']
# tup = (1,2,3)
# lst.extend(tup)

# strvar = "abc"
# lst.extend(strvar)

lst.extend(range(3))
print(lst)

 

删

1.pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)

st = ["曹静怡","王志国","邓鹏","合理"]
# 不指定下标,默认删除最后一个
res = lst.pop()
print(res)
print(lst)

# 指定下标,删除具体某个元素
res = lst.pop(1)
print(res)
print(lst)

2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个

lst = ["曹静怡","王志国","合理","邓鹏","合理"]
res = lst.remove("合理")
print(res)
print(lst)

3.clear 清空列表

lst = ["曹静怡","王志国","合理","邓鹏","合理"]
lst.clear()
print(lst)

 

改 查

参考列表的相关操作

 

列表的其他相关函数

index 获取某个值在列表中的索引

lst = ["曹静怡","王志国","合理","邓鹏","合理","邓鹏辉","邓鹏蓝","合理","邓鹏绿"]
res = lst.index("合理")
res = lst.index("合理",3)
res = lst.index("合理",3,6) # 3 4 5
# res = lst.index("合理大") error
print(res)

count 计算某个元素出现的次数

res = lst.count("合理") # 没有范围的概念
print(res)

sort 对列表排序

lst = [-90,-100,-1,90,78]
# 从小到大进行排序
lst.sort()
# 从大到小进行排序
lst.sort(reverse=True)
print(lst)

对字符串进行排序(按照ascii编码)

lst = ["kobi","james","jordon","yaoming","yi"]
lst.sort()
print(lst)

是否可以对中文排序(了解 无规律可循)

lst = ["王文","蔡徐坤"]
lst.sort()
print(lst

reverse 列表反转操作

lst = [1,2,"a","蔡徐坤","易烊千玺"]
lst.reverse()
print(lst)

 

列表的深浅拷贝

a = 100
b = a
a = 200
print(b)

lst1 = [1,2,3]
lst2 = lst1
lst1.append(4)
print(lst2)

1.浅拷贝

import copy

模块.方法() 同名模块下的同名方法

方法一 (推荐)

lst1 = [1,2,3]
lst2 = copy.copy(lst1)
lst1.append(10)
print(lst2)
print(lst1)

方法二

lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(11)
print(lst1)
print(lst2)

2.深拷贝

把所有层级的容器元素都单独拷贝一份,放到独立的空间中

"""
# 现象
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1[-1].append(77)
lst1.append(8888)
print(lst2)
print(lst1)
"""

import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst1)
lst1[-1].append(999)
print(lst2)
print(lst1)

 

其他容器的深拷贝

lst1 = (1,2,3,{"a":1,"b":[10,20]})
lst2 = copy.deepcopy(lst1)
lst1[-1]["b"].append(30)
print(lst1)
print(lst2)

总结: 浅拷贝:只拷贝一级容器中的所有元素独立出一个单独的空间

深拷贝: 把所有层级的容器中所有元素都单独拷贝一份,形成独立的空间

 

tuple 只有count index 两个方法 使用同列表

 

字典的相关函数

dic = {}

增

1.普通方法  (推荐)

dic["top"] = "369"
dic["middle"] = "左手"
dic["bottom"] = "杰克爱"
print(dic)

2.fromkeys 使用一组键和默认值创建字典

tup = ("a","b","c")
# fromkeys(盛放键的容器,默认值)
dic = {}.fromkeys(tup,None)
print(dic)

注意点 (字典中的三个键默认指向的是同一个列表)

dic= {}.fromkeys(tup,[])
print(dic)
dic["a"].append(1)
print(dic)

改造

dic = {}
dic["top"] = []
dic["middle"] = []
dic["bottom"] = []
dic["top"].append("the boy")
print(dic)

 

删

pop()       通过键去删除键值对 (若没有该键可设置默认值,预防报错)

dic = {'top': '369', 'middle': '左手', 'bottom': '杰克爱'}
res = dic.pop("middle")
print(res)
print(dic)
# 可以给pop设置第二个参数值,以防止键不存在时报错
res = dic.pop("middle1234","该键不存在")
print(res)

popitem()   删除最后一个键值对 

dic = {'top': '369', 'middle': '左手', 'bottom': '杰克爱'}
res = dic.popitem()
print(res)
print(dic)

clear()  清空字典

dic.clear()
print(dic)

 

改

update() 批量更新(有该键就更新,没该键就添加)

推荐使用

没该键就添加

dic_new = {"jungle":"karsa","support":"宝蓝"}
dic = {'top': '369', 'middle': '左手', 'bottom': '杰克爱'}
dic.update(dic_new)
print(dic)

有该键就更新

dic_new = {"top":"the bug","support":"xboyww","xiaozhang":"王思聪"}
dic.update(dic_new)
print(dic)

(了解)

dic.update(ww="王文",zl="张磊")
print(dic)

 

查

get()    通过键获取值(若没有该键可设置默认值,预防报错)

dic = {"top":"the bug","support":"xboyww","xiaozhang":"王思聪"}
# res = dic["top123"]
# get 在获取字典键时,如果不存在,不会发生任何报错,返回的是None
res = dic.get("top123")

# 可以在获取不到该键时,给与默认值提示.
res = dic.get("top123","抱歉,该键不存在")
print(res)

 

其他操作

keys()   将字典的键组成新的可迭代对象

dic = {"top":"the bug","support":"xboyww","xiaozhang":"王思聪"}
res = dic.keys()
print(res , type(res))

values() 将字典中的值组成新的可迭代对象 ***

res = dic.values()
print(res , type(res))

items()  将字典的键值对凑成一个个元组,组成新的可迭代对象 ***

res = dic.items()
print(res , type(res))


# for i in res:
    # print(i)
for k,v in res:
    print(k,v)

 

 集合的相关操作（交差并补）

intersection() 交集 

set1 = {"易烊千玺","王一博","刘某PDD","王文"}
set2 = {"倪萍","赵忠祥","金龟子大风车","小龙人","王文"}

res = set1.intersection(set2)
print(res)

简写 &

res = set1 & set2
print(res)

difference()   差集

res = set1.difference(set2)
print(res)

简写 -

res = set1 - set2
print(res)

union()  并集

res = set1.union(set2)
print(res)

简写 |

res = set1 | set2
print(res)

 

symmetric_difference() 对称差集 (补集情况涵盖在其中)

res = set1.symmetric_difference(set2)
print(res)

 

简写 ^

res = set1 ^ set2
print(res)

 

issubset()   判断是否是子集

set1 = {"刘德华","郭富城","张学友","王文"}
set2 = {"王文"}
res = set2.issubset(set1)
print(res)

 

简写 <

res = set2 < set1
print(res)

 

issuperset  判断是否是父集

set1 = {"刘德华","郭富城","张学友","王文"}
set2 = {"王文"}
res = set1.issuperset(set2)
print(res)

简写>

res = set1 > set2
print(res)

 

isdisjoint() 检测两集合是否不相交  不相交 True  相交False

 

set1 = {"刘德华","郭富城","张学友","王文"}
set2 = {"王文"}
res = set1.isdisjoint(set2)
print(res)

 

集合的相关函数

增

add()    向集合中添加数据  一次加一个

set1 = {"王文"}
set1.add("王伟")
print(set1)

update() 迭代着增加 一次加一堆

set1 = {"王文"}
lst = ["a","b","c"]
lst = "ppp" # 迭代这添加,无序,会自动去重
set1.update(lst)
print(set1)

 

删

clear() 清空集合

setvar = {'刘某PDD', '小龙人','倪萍', '赵忠祥'}setvar.clear()print(setvar)

pop()     随机删除集合中的一个数据

res = setvar.pop()
print(res)
print(setvar)

discard() 删除集合中指定的值(不存在的不删除 推荐使用) ***

setvar.discard("刘某PDD111111") # success
setvar.discard("刘某PDD")
print(setvar)

remove()  删除集合中指定的值(不存在则报错) (了解)

setvar.remove("刘某PDD111") # error
setvar.remove("刘某PDD")
print(setvar)

 

 

3.冰冻集合 (额外了解)

frozenset 单纯的只能做交差并补操作,不能做添加或者删除的操作

lst = ["王文","宋健","何旭彤"]
fz1 = frozenset(lst)
print(fz1, type(fz1))

 

不能再冰冻集合中添加或者删除元素

fz1.add(1)
fz1.update("abc")
fz1.discard("王文")

 

冰冻集合只能做交差并补

lst2 = ["王文","王同培","刘一缝"]
fz2 = frozenset(lst2)
print(fz2, type(fz2))

 

交集

res = fz1 & fz2
print(res)

遍历冰冻集合

for  i in fz2:
    print(i)