当前位置 博文首页 > HashFlag的博客：Python基础
b = bit 位（比特）；B = Byte 字节
1Byte = 8bit；1KB = 1024B；1MB = 1024KB；1GB = 1024MB；1TB = 1024GB；1PB = 1024TB；1EB = 1024PB
二进制：0b表示 0b101 = 1*2^0 + 0*2^1 + 1*2^2
八进制：0o表示 0o127 = 7*8^0 + 2*8^1 + 1*8^2
十进制：正常显示
十六进制：0x显示 0xFF = 15*16^0 + 15*16^1 = 255
二进制转换八进制：(三位原则：指二进制的每三位对应一位八进制数)
二进制与八进制对应关系：
八进制 二进制
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111
二进制转换十六进制：(四位原则：指二进制的每四位对应一位十六进制数)
二进制与十六禁止的对应关系：
十六进制 二进制
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
a 1010
b 1011
c 1100
d 1101
e 1110
f 1111
八进制转换十六进制：
先转换二进制然后通过二进制转换
原码：二进制的表现形式
? 原码特点：第一位是1
? 0000… 1 表达数字正1
? 1000… 1 表达数字负1
反码：二进制码0与1互相转化
补码：二进制的存储形式
? 补码特点：高位都是1
? 0000… 1 表达数字正1
? 1111… 1 表达数字负1
注：原码与补码转化为反码时首位符号位不变
运算的顺序：补码 —> 原码 —> 显示的内容
转换规律：
? 正数的原码，反码补码相同；
? 负数的原码与补码之间是互为取反加1的关系：
? 原码 = 补码取反加1
? 补码 = 原码取反加1
注：进制转换的时候需要先把内存存储的补码拿出来变成原码在进行转换输出
? Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。
python 2.X 版本，官方在2020年停止支持，原码不规范，重复较多
python 3.X 版本，功能更强，修复了很多bug，原码清晰。
编译型：一次性把所有代码编译成可识别的二进制代码，再执行
如：C， C++，java
解释型：代码从上到下一行一行的解释并运行
如：python，javascript，php
（1）Cpython（官方推荐，也是最常用的）：是把python代码转化成C语言可识别的二进制代码
（2）Jpython：是把python代码转化成Java语言可识别的二进制代码
（3）其他语言解释器：把python转化成其它语言能识别的二进制码
（4）PyPy：将所有代码一次性编译成二进制码，加快执行效率（模仿编译型语言的解释器）
1.1 变量的概念
? 可以改变的量，实际指代的是内存中的空间
rujia_305 = "王闻"
rujia_305 = "主胜"
print(rujia_305)
1.2 变量的声明
第一种命名方式
a = 100
b = 200
print(a)
print(b)
第二种命名方式
a,b = 100,200
print(a,b)
第三种命名方式
a = b = 500
print(a,b)
1.3 变量的命名规则
? 字母数字下划线，首字符不能为数字，严格区分大小写，不能使用关键字，变量命名有意义，且不能使用中文名命。
1.4 关键字
#import 引入 keyword模块
import keyword
print(keyword.kwlist)
"""
'False', 'None', 'True', 'and',
'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif',
'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import',
'in', 'is', 'lambda', 'nonlocal',
'not','or', 'pass', 'raise', 'return',
'try', 'while', 'with', 'yield'
"""
注：变量的名命不能使用关键字；Python 支持中文，但是不能使用中文
1.5 编码
? Python 支持中文，但严禁使用中文（容易出现乱码占用空间）
? utf-8 国际标准编码（可变长的unicode编码）中文字符占用3个字节，英文数字特殊符号占用1个字节
? gbk 国标编码，中文字符占用2个字节，英文或者符号占用1个字节
1.6 变量的转换
# 通用写法
a = 20
b = 21
temp = a
a = b
b = temp
print(a,b)
# python特有
a = 23
b = 24
a,b = b,a
print(a,b)
1.7 常量的定义：约定俗称全都变成大写
? CHANGLIANG = “nepenthe”
intvar = 25
print(type(intvar))
res = id(intvar)
print(res)
2.3.1 int 类型
intvar = 25
print(type(intvar))
# 二进制整型
inttowB = 0b10
print(inttowB)
print(type(inttowB))
print(id(inttowB))
# 八进制整型
inteightO = 0o127
print(inteightO)
print(type(inteightO))
print(id(inteightO))
# 十六进制整型
intsixthX = 0xA
print(intsixthX)
print(type(intsixthX))
print(id(intsixthX))
2.3.2 float 浮点型（小数）
# 表示方式一
floatvar = 3.14
print(floatvar)
print(type(floatvar))
# 表达方式二
floatvar = 5.1e4
print(floatvar)
print(type(floatvar))
2.3.3 bool 布尔类型； True 真 False 假；只有这两个值。
2.3.4 complex 复数：形如a+bj
# 复数表达方式一
complexvar = 3-10j
complexvar = 20j
print(complexvar)
print(type(complexvar))
# 表达方式二
complexvar = complex(3,-10)
print(complexvar)
print(type(complexvar))
2.4.1 字符串：用引号引起来的就是字符串
（1）单引号字符串 ‘ ’
（2）双引号字符串 “ ”
（3）三引号字符串 ‘’‘ ’‘’ “”“ ”“” （三引号会保留原始格式）
（4）元字符串 r" " 不转义字符，原型化打印字符串
（5）格式化字符串 ：“ 字符串 ” %（值1，值2，值3）
%d 整型占位符
%2d 占两位 原字符串默认居右
%-2d 占两位 原字符串默认居左
%f 浮点占位符（存在四舍五入的情况）
%.2f 小数点保留两位小数
%s 字符串占位符
2.4.1.1 转义字符： \ + 字符
（1）\ 可将有意义的字符变成无意义
（2）\ 可将无意义的字符变成有意义
（3）\n, \r\n 换行；
（4）\t 缩进 水平制表符（一般是四个空格的距离）
（5）\r 将\r后面的字符直接拉到当前行行首
2.4.2 list列表（有序，可修改，可获取）
定义空列表：listvar = [] 或 listvar = list()
（1）索引
? 正向索引：正向索引以 0 开始 0 1 2 3 4
? 逆向索引：逆向索引以 -1 开始 -1 -2 -3 -4
（2）获取列表中的最后的元素：直接使用listvar [-1]（python特有）
其他语言通用写法 通过len方法获取列表长度获取最后元素值 listvar [len(listvar )]
（3）修改列表元素值 listvar [0] = 赋值
2.4.3 tuple 元组（有序，不可修改，可获取）
定义空元组：tuplevar = () 或 tuplevar = tuple()
单纯的（）不能代表元组类型，逗号才是元组的标识符：
tuplevar = 2，也是个元组
注：tuplevar =（1）不是元组，tuplevar = （1，）才是
（1）索引
? 正向索引：正向索引以 0 开始 0 1 2 3 4
? 逆向索引：逆向索引以 -1 开始 -1 -2 -3 -4
2.4.4 str字符串（有序，不可修改，可获取）
字符串的定义：strvar = “哈哈哈”
获取字符串中的元素：strvar[1]
元字符串：r“nepenthe ”；使用r声明的字符串是元字符串
2.4.5 set集合类型（作用：交叉并补；特点：无序，自动去重， ）
# 定义集合
setvar = {"刘德华","郭富城","张学友","黎明"}
# 自动去重
setvar = {"刘德华","郭富城","张学友","黎明"，"刘德华","郭富城","张学友","黎明"}
print(setvar)
# 定义空集合
setvar = {}
setvar = set()
print(setvar, type(setvar))
2.4.6 dict字典类型（特点：以键值对存储数据，表面上有序，实际上无序）
? 语法：divtvar = {键1：值1，键2：值2，. . . }
"""
字典的键：推荐用变量命名的字符串进行使用
字典的键和集合的值有数据类型上的要求
可哈希的数据类型可以做字典的键：Number（int，float，bool，complete），str，tuple
可变类型，不可哈希（不可被应用在set中和字典的键）：list dict set
哈希算法都是典型的无序特征，目的：为了更加均匀的把数据分配到内存中，随机，无序，底层用了取模类似的算法。
python3.6版本，对字典做了优化，存储数据的时候用的哈希算法
但是在拿出数据的时候，重新按照定义的顺序做了排序，所以看起来有序，实际是无序的
"""
# 定义空字典
dictvar = {}
dictvar = dict()
# 定义普通字典
dictvar = dict{"name":"eric", "sex":"男", "age":"22", "hobby":"无"}
# 获取字典值
dictvar['name']
# 修改字典值
dictvar['name'] = "jack"
# 字典的键有一定要求
dictvar = {1:'asdf', False:'asd', 1+2j:'asd', 3.14:'asd', (1,2):"asd", "中文":"asd"}
可哈希的都不可变，不可哈希的都可变
Number、String字符串、tuple元组是可哈希数据类型
dict字典、set集合、list列表是不可哈希数据类型
数值型数据类型：number、string、tuple
引用型：list、set、dict
整型：-5 ~ 正无穷范围内的值相同 id 值一致
var1 = 1
var2 = 1
浮点数：非负数范围内的两个值相同时 id 值一致
var1 = 1.0
var2 = 1.0
布尔值：值相同的情况下，id一致
var1 = True
var2 = False
print(id(var1),id(var2))
复数对于 实数+虚数 这种结构中永不相同（只有虚数的情况例外）
intvar1 = 1+2j
intvar2 = 1+2j
intvar3 = 1j
intvar4 = 1j
print(id(intvar1),id(intvar2),id(intvar3),id(intvar4))
字符串和空元组相同的情况下，地址相同
var1 = "你"
var2 = "你"
var3 = ()
var4 = ()
print(id(var1),id(var2),id(var3),id(var4))
列表，元组，字典，集合无论什么情况id值都不同(空元组例外)
listvar1 = [1,2,3]
listvar2 = [1,2,3]
setvar3 = {1,2,3}
setvar4 = {1,2,3}
dictvar5 = {1:'2'}
dictvar6 = {1:'2'}
print(id())
类型转换方法：int（），bool（），float（），complex（）
强制转换整型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = int(1.0)
var2 = int('12')
var3 = int(False)
var4 = int(12)
强制转换浮点型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = float(1.1)
var2 = float('12')
var3 = float(False)
var4 = float(12)
强制转换布尔型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = bool(1.1)
var2 = bool('12')
var3 = bool(False)
var4 = bool(12)
强制转化布尔型为假的十种情况
0 0.0 False 0j () [] {} set() '' None
强制转换成复数(纯数字字符串，浮点型，布尔型，整形)
var1 = complex(1.1)
var2 = complex('12')
var3 = complex(False)
var4 = complex(12)
? 转换原则：数据精度默认从低到高转换：bool int float complex
bool + int 布尔类型 + int整型 = 整型
ret = True + 12
bool + float 布尔类型 + float浮点型 = 浮点型
ret = True + 1.2
bool + complex 布尔类型 + complex复数 = 复数
ret = True + 1+2j
int + float int整型 + float浮点型 = 浮点型
ret = 1 + 1.1
int + complex int整型 + complex复数 = 复数
ret = 1 + 1+2j
float + complex float浮点型 + complex复数 = 复数
ret = 1.1 + 1+2j
强制转化成str字符串（Number类型数据和容器类型数据都可以转化）
ret = str([1,2])
强制转化成元组(自身转化无变化)
ret = tuple("sfaf") 字符串强制转化成元组会拆分成单个字符 ("s","f","a","f")
ret = tuple([1,2,3]) 列表强制转化成元组表面上看就是换了外面的括号
ret = tuple({1,2,3}) 集合强制转化成元组表面上看就是换了外面的括号
ret = tuple({1:'1',2:'2'}) 字典强制转化成元组只会保留字典的键以元组的方式呈现
Number数据类型不能强制转化成元组
强制转化成列表(自身转化无变化)
ret = list("sfaf") 字符串强制转化成列表会拆分成单个字符 ("s","f","a","f")
ret = list((1,2,3)) 元组强制转化成列表从表面上看就是换了外面的括号
ret = list({1,2,3}) 集合强制转化成列表从表面上看就是换了外面的括号
ret = list({1:'1',2:'2'}) 字典强制转化成列表只会保留字典的键以元组的方式呈现
Number数据类型不能强制转化成列表
强制转化成集合(自身转化无变化）
ret = set("sfaf") 字符串强制转化成集合会被拆分成单个字符并自动去重 ("s","f","a")
ret = set([1,2,3]) 列表强制转化成集合会自动去重，从表面上看外层括号会变成{}
ret = set((1,2,3)) 元组强制转换成集合会自动去重，从表面上看外层括号会变成{}
ret = set({1:'1',2:'2'}) 字典强制转化成列表只会保留字典的键以集合的方式呈现，并会自动去重
强制转化成字典(自身转化无变化)
注：强转成字典时，必须是等长的二级容器，元素个数为2
外层可以是列表、元组或集合，里面的容器是元组或者列表
ret = [(1,2,),[1,2]]
ret = ((1,2,),[1,2])
ret = {(1,2,),[1,2]} # 注：集合中不能存在字典
如果里面出现集合（外层不是set集合{}），语法上是允许的，但有局限性
ret = ([1,2],{1,2})
如果里面出现字符串，语法上是允许的，但有局限性，字符串的长度只能是2
ret = ([1,2],'as')
二级列表
ret = [1,[2,3]]
二级元组
ret = (1,(2,3,),)
二级集合
ret = {1,{1,2}}
二级字典
ret = {1:'1',{1:'2'}}
多级容器就是嵌套使用
加+、减-、乘*、除/（结果永远是小数）、地板除 //、取余%、幂运算**（优先级最高）
地板除// ：如果除数或者被除数存在小数，那结果上加上 .0
取余% ：
? 81 % 11 = 4
? -81 % 11 = -4 + 11 =7
? 81 % -11 = 4 + ( -11 ) = -7 （正数取余的余数的正负取决于被除数的正负，正数取余的余数加上除数的结果就是真正的余数）
? -81 % -11 = -4 （如果被除数和除数都是负数，在正常得到的结果上加上负号）
var1 = 2
var2 = 4
加+
ret1 = var1 + var2
减-
ret2 = var1 - var2
乘*
ret3 = var1 * var2
除/
ret4 = var1 / var2
地板除 //
ret5 = var1 // var2
取余%
ret6 = var1 % var2
幂运算**
ret7 = var1 ** var2
print(ret1, ret2, ret3, ret4, ret5, ret6, ret7)
> < >= <= == != 只会产生两个结果：True和False
= ：一个等号是赋值，把等号右边的值赋给左边
==：两个等号是在做比较，判断左右值是否相同
!=：判断两个值是否不等
var7 = 20
var8 = 20
ret8 = var7 > var8
ret9 = var7 < var8
ret10 = var7 >= var8
ret11 = var7 <= var8
ret12 = var7 == var8
ret13 = var7 != var8
print(ret8, ret9, ret10, ret11, ret12, ret13)
= 等号、+=加等、-=减等、*=乘等、/=除等、//=地板除等、%=取余等、**=幂等
= 等号
rew1 = 12
rew2 = 2
+=加等
rew2 += rew1
-=减等
rew2 -= rew1
*=乘等
rew2 *= rew1
/=除等
rew2 /= rew1
//=地板除等
rew2 //= rew1
%=取余等
rew2 %= rew1
**=幂等
rew2 **= rew1
print(rew2)
in 和 not in （针对于容器类型数据）
注：字符串必须是一个连续的片段
list列表 tuple元组 set集合
dict字典（in 和 not in 在字典中只判断键不能判断值）
rew3 = "asdpwdzxc"
rew4 = ['asd', 'pwd', 'zxc']
in 和 not in 字符串
rew5 = "asd" in rew3
rew6 = "dsa" in rew3
rew5 = "asd" not in rew3
rew6 = "dsa" not in rew3
in 和 not in 列表（元组，集合）
rew7 = 'ass' in rew4
rew8 = 'asd' in rew4
rew7 = 'ass' not in rew4
rew8 = 'asd' not in rew4
print(rew5, rew6)
print(rew7, rew8)
in 和 not in 字典
rew9 = {'as': '阿斯蒂', 'zs': '安中学'}
rew10 = 'as' in rew9
rew11 = 'bs' in rew9
rew10 = 'as' not in rew9
rew11 = 'bs' not in rew9
print(rew10, rew11)
is 和 is not （检测两个数据在内存中是否是相同的地址）
整型，浮点型，布尔型
qwe1 = 90
qwe2 = 90
qwe1 = -90
qwe2 = -90
qwe1 = -90.9
qwe2 = -90.9
qwe1 = True
qwe2 = False
复数类型
qwe1 = 0j
qwe2 = 0j
qwe1 = 1 + 2j
qwe2 = 1 + 2j
容器类型
qwe1 = ()
qwe2 = ()
qaq1 = qwe1 is qwe2
qaq2 = qwe1 is not qwe2
print(qaq1, qaq2)
and逻辑与（&&）、or逻辑或（||）、not逻辑非（！）
and逻辑与（全真即真，一假即假）
or逻辑或（一真即真，全假即假）
！逻辑非（真变假，假变真）
逻辑短路：如果出现短路效果代码就不知执行了
? True or 表达式 真
? False and 表达式 假
注：print是内置函数，函数内部返回的是None，功能是打印
and逻辑与（&&）
qwe3 = True and False
qwe4 = False and False
qwe5 = True and True
qwe6 = False and False
or逻辑或（||）
qwe3 = True or False
qwe4 = False or False
qwe5 = True or True
qwe6 = False or False
print(qwe3, qwe4, qwe5, qwe6)
not逻辑非（！）
qwe7 = not True
qwe8 = not False
特殊的情况 短路
qwe7 = True or True
qwe8 = True or False
qwe7 = 5 or 6
qwe8 = 0 or 6
qwe7 = 5 and 6
qwe8 = 0 and 6
print(qwe7, qwe8)
