python基础

Posted 2022-02-06 shuai222

一、基础数据类型

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="")
    <
以上是关于python基础的主要内容，如果未能解决你的问题，请参考以下文章
 
 001--python全栈--基础知识--python安装
 Python基础之函数
 python 目录
 python基础
 人生苦短，我用Python(目录)
 Python基础--Python3基础语法