Py修行路 python基础（六）前期基础整理

计算机中，有且仅有CPU具有执行权限，能够执行指令的只有CPU！

人在应用程序上输入的文字或文本，叫做明文！

在屏幕上输入或是输出的是字符，计算机保存的是 有字符编码的 二进制数。

变量赋值规则：例如：a=1

先在内存中开辟一块空间，存放数1，内存上会有一个相对应的id号，然后变量a指向这块内存区域和id号，python编译器有垃圾清除的功能，若开辟的这块内存区域一段时间内不调用，数据就会被清除，为其他的数据腾空间。

python2 容错率高，自作聪明的完成转码拼接。

python3 将字节类型和字符串类型完全清晰的分开了，如果不同类型拼接，会报错！

 

#字符编码

ASCII码：127个数字：7个比特位 ----------->美国

扩展ASCII码： 256个数字：  8个比特位 --------->拉丁

中文扩展ASCII码（GB2312）：几千个状态----------> 中国

中文扩展ASCII码（GBK）：两万个状态----------> 中国

unicode（明文：二进制数字）：两个字节 ------------>六万多个状态 -------全世界

utf-8（二进制对应二进制）：-------全世界

 

py2.X 中        str ： bytes数据         unicode：unicode编码后的二进制数据

py3.X中        str  ： unicode(u)      bytes ：bytes(b) <存储和传输时使用>

知识点：

1、unicode(2个字节，万国码)，utf-8（可变长的编码，英文1个字节，中文3个字节）,GBK（2个字节）都是编码方式。

2、内存存储unicode 格式的二进制数据（可理解为文件）。

3、文本以utf-8等编码方式将内存中unicode编码的文件保存到硬盘之中。utf-8格式下的存储文件占空间小。

 repr()：查看字节数据

不同形式的编码，前边都有标志（unicode 对应u）

 

decode(参数)：参数：指解码规则！（解码）

encode(参数)：参数：指编码规则！（编码）

 

python2 容错率高，自作聪明的完成转码拼接。 

python3 将字节类型和字符串类型完全清晰的分开了，如果不同类型拼接混用，会报错！字符串中可以使用的方法对字符串或是字节数据是一样的操作！

 

IDE编译器执行没问题，但不一定终端执行没问题，可以先在IDE上执行测试，将输出的数据改成unicode 格式，在终端测试，再一种是先判断终端是哪种格式的编码，改IDE编译器的编码格式 #coding:****  ***代表编码规则，再在终端上判断测试。

 

注意点：

1、unicode，utf-8,GBK 都是编码规则。

2、为什么内存存储unicode。

任何数据执行都先放到内存中，编码和解码都是在文件执行的过程中完成的操作。

 

编码：明文 ----------->二进制数据

解码：bytes数据 ---(解码方式)-----> 二进制数据

 

对象.方法（）  <对象一定对应着可以调用的方法！>

 

#变量

1、不能以数字，特殊字符开头，  下划线_可以使用，在命名之中。

2、不能以关键字命名

 

缩进  及控制块。if，循环，函数！

注释：#或是三个‘‘‘’’’或“““”””

#运算符：

算术运算符：+  -  *  /

赋值运算符： =  +=  -=  *=  /=

比较运算符：==（等于） >=  <=  !=   比较结果，返回布尔值！(一定是布尔值！)

逻辑运算符： and（与）  or（或）  not（非）

True and False  -------> False      False and False ----------> False

判断会一个一个去执行判断，从第一个开始；

or 取决权在第一个符号，某件事将结果决定了，就会按照决定值返回；而and相反，取决权在后边的符号：若第一个对了，会往后再判断，以最后起作用的返回值为准。

 

关系运算符  in  not in   是不是属于同一个对象，返回布尔值！

位运算符  

 

#数据类型

整型  int   仅有一种表达方式，叫长整型。

可变数据类型：列表，字典

不可变数据类型：整型 元组 字符串  -----------> 一旦创建，不能修改

浮点型  float （f），科学技术法   E代表10的负一次方  0.000123   1.23e-4

folat   double     精度不一样

布尔值 其本身就是一个数据类型（True = 1 False = 0）,可做计算。

 

流程控制

 

#字符串（string:）

s='let\'s go'  \转义符号

原生字符串 print（r"\fsjiaakdxie."）

 

查找 ：切片 [:]

s1 = "hello world" print(s1[1:4])  print (s1[1:4:2])

.strip(“参数”)  把字符串开头和结尾的空格以及\n去掉。参数可以是任何一个字符结构。

 

拼接方法 

+方法   s="hello"+"world"  效率的高低，取决于拼接文件的个数。两个拼接之后再去开辟内存空间存储合并之后的数据。以此类推。

join 方法   "*".join(["I","am","world"])以*为间隔，将字符串拼接在一起。右边是列表格式的字符串，整型不能改变，所以拼接不了！

分割方法

"字符串".split("分隔符"，最大分割数)   s="hello world".split(" ")   以空格为分割符将字符串分开，生成一个列表。以某个分割符来分割的话，结果中分隔符不会留下。

. rsplit() 对字符串从右往左分割！

.splitlines()  对字符串根据换行符进行分割。

 

查找字符  find()   找不到不会报错

print("hello world".find("l"))   从左往右查找，找到一个就返回索引值

print("hello world".rfind("l"))   从右往左查找，找到一个就返回索引值

print("hello world".find("l"，3))   从左往右 索引为3的位置 查找，找到一个就返回索引值。

print("hello world".index("l"))   从左往右查找对应字符的索引值，找到就返回，找不到就报错。

 

替换

print("hello world".replace("world","python"))   完全匹配，一对一的去匹配，只要一个字符匹配不上就会报错。

 

对 字符串 这种不可变数据操作，都会有一个返回值，原字符串不会发生改变。

 

大小写互换

print("Hello world".swapcase())  大写变小写，小写变大写！

首字母大写

print("Hello world".capitalize())   字符串开头，第一个字母大写！

标题

print("Hello world".title())   字符串，第一个单词的首字母大写！

"hEllo woRld".upper()  不管字符串中有没有大小写，全部变成大写！

"hEllo woRld".lower()  不管字符串中有没有大小写，全部变成小写！

 

位置对齐

print("hello world".center(50,"*"))  居中显示hello world，所有文本占50个字符，其他空白位置由*填充。

print("hello world".ljust(50,"*"))  左对齐

print("hello world".rjust(50,"*"))  右对齐

 

.zfill()  占多少个字符，多出来的补零。字符串靠右。

 

字符串的格式化输出 .format()  字符串中填充的位置和后边添加的字符串，是一一对应的关系。

 

.format_map() 括号中存放的才是字典。

 

print("hello %s,%s"%("sb","egon"))

占位符

%s 字符串

%d 整型

%f 浮点型

 

判断字符串是否是数字

"12".isdecimal()

"-12".isdigit()

"34".isnumeric()  针对性很强，对于汉语中的数字，也可以识别

print 输出，返回布尔值。

 

占空格

"hEllo\twoRld".expandtabs()  默认8个空格，作用于\t ，若是想错开多点，在后边括号内输入想扩展的数字。

 

is开头的都是判断函数，对字符串操作完之后，会返回布尔值，对就是True，错就是Flase.

 

列表      可迭代对象： 能够进行for循环的

#创建形式  l = [ 1,"hello",[4,5],{"name":"egon"}]

l2 = list([])  []叫做序列，要放到列表中的元素总结起来。

 

#查： 切片[:]

   拿到列表的索引值及对应的元素。

第一种方法：利用标志位

count=0 

for i in [11,22,33]:

    print("%s---------%s"%(count,i))

count+=1

 

第二种方法：

l = [11,22,33]

for i in l:

    print(l.index(i),i)

 

第三种方法：enumerate() 函数 自动生成序号和值

l = [11,22,33]

for i,v in enumerate(l，1):  #函数后可以自定义序号。

print(i,v)

 

#增加    此操作没有返回值！

l.append()   追加，在最后一个位置添加，每次只能添加一个对象！！！

添加多个元素：l.extend()  

可以添加多个元素，中间用，分开，或是放个列表。l.expend([7,8])

指定位置添加插入：  .instert(位置，元素)  例子：l.instert(2,"zhang")

 

#删除

通过位置删除：l.pop()  默认删除最后一个，可以指定位置。  有返回值！！！，返回值为删除的元素。

删除某个具体内容：l.remove()  括号中放入要删除的元素。

删除整个，或是一段的列表  del l[1]   del l[]   del l[1:3]

 

#改  赋值操作！！！

通过索引值的位置   l[2][0]="字符串"   字符串内的数据发生改变，但是所对应的内存地址没有改变。

清空 l.clear()   将列表内的所有数据清空！！！   与l4=[]不是一样的列表  #推荐新建的方式。清空原列表，没有新建一个空列表，效率高！

 

#计算数量 .count()  统计列举中某个元素的数量

[[1,2,3,4].count(3) 

 

统计列表所有的个数：len  print(len(l))

 

#排序：.sort()  从小到大排序，没有返回值！    ord 内置函数，查看ASCII码！

排序顺序可以自己调整，reverse =True(从大到小排)  reverse =False（从小到大排）

 

sorted([1,2,3])   内置函数，sorted() 也可以进行排序！

max()最大值  min()最小值

 

#复制 浅copy 和深copy

 

#反转

.reverse() 不管列表内数据的顺序，直接反转排序。

 

元组  是不可变类型，数据不能更改！

#创建

t = (1,2,3)  print(t)

t2 = tuple([1,2,3])  print(t2)   

#不能进行修改操作

#查

print(t[:])  打印所有

 

字典

python中唯一具有映射关系的数据类型：字典的查询效率高于列表

#创建  键唯一且为不可变数据类型！

d={"name":"alex","age":23}

#查

print(d["name"])

v=d.get("name",None)  #推荐

print(v)

 

#遍历查询

for 循环，取到的是字典的键！

for i in d

   print(i,"-------->"d[i])  #对应打印字典里的键值对

   print("%s------>%s"%(i,d[i]))  #格式化打印

 

可以用list 转换成列表

print(d.keys())   #将键全部写入一个列表

print(d.values())  #将值全部写入一个列表

print(d.items()) #将字典中的键值对，每对组成一个元组，整体组成一个列表输出。

 

#增

d["age"]=123 

 

#修改

d["键"] =值   d["1"]=666

 

#删除

根据键删除    d.pop("1")  有返回值！  .popitem() 随机删除一个

任何数据都可以删除的  del

d.clear()  将字典整个清空，然后留下空字典。

 

d.update() #增加字典，如果字典中没有就添加，有就覆盖。

d2={"height":123,"sex":"male",}

d.update(d2)

print(d)

 

for i in (序列对象seq)：#seq可以是字符串，列表，元组，字典！

循环

1、循环次数由序列的一级元素的个数决定！

2、item 是定义的一个变量    range()对应一个列表，默认从0走，可以自定义起始位置。

continue  #结束本次循环

break  #结束整个循环

 

while 循环     死循环！

while 条件表达式 或是 布尔值：

执行代码

集合set   跟字典是一套，就是没有值  两个功能：1、去重，2、关系测试

          是可变的数据类型！  print({[1,2]:"hello"}) 会报错！

          set集合内的元素一定是不可变数据类型！print({1,2,[3,4]}) 会报错！

 

s = set([1,3,"hello"])  或是  s2={1,2,3}

print(s，s2)

 

#去重：

l = [1,2,2,34,45]

s="hello"

print(set(l))  

print(set(s))    输出结果｛"h","e","l","o"｝去除重复的“l”，输出一个！

 

#关系测试

s1 = {"hello",1,2,3}

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

linux={"hello",4,5,6}

python={"hello",3,4,5}

#求并集

print(s1.union(s2))

print(s1 | s2)

 

#求交集   两个都有

print(s1.intersection(s2))

print(s1 & s2)

 

#求差集   我有对方没有的东西

print(s1.difference(s2))

print(s1 - s2)

 

#对称差集  把都没有的合并起来。#把两个互相不在的全打印 

print(s1.symmetric_difference(s2))

print(s2.symmetric_difference(s1))

print(s1^s2)

 

 

两个集合合并  天然去重！把python合并到linux集合中

linux.update(python)

增加一个新的  linux.add("Alex")

删除 linux.discard("alex") #删除，如果元素不存在，不会报错

     linux.remove("alex")# 删除，如果元素不存在，会报错

随机删 linux.pop() #随机删除

 

linux.issubset(python) #子集  判断是否是子集

linux.issuperset() #超集，父集  判断可用<,>进行