Python基础知识点

编程语言的进化：机器语言、汇编语言、高级语言

机器语言：由于计算机内部只能接受二进制代码，因此，用二进制代码0或1描述的指令称为机器指令，全部机器指令的集合构成计算机的机器语言。

汇编语言：实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用英文缩写的标识符，更容易识别和记忆。

高级语言：高级语言对开发人员更加友好，开发效率大大提高
高级语言所编制的程序不能直接被计算机识别，必须经过转换才能被执行。

高级语言按转换方式可分为：编译型、解释型
编译型：指在应用源程序执行之前，将程序源代码转换成目标代码，因此其目标代码可以脱离其语言环境独立执行。
编译后程序运行时不需要重新翻译，直接使用翻译的结果就行。程序执行效率高，依懒性编译器，跨平台性差。如C、C++、GO、Delphi等

解释型：应用程序源代码一边由相应语言的解释器翻译成目标代码，一边执行，因此效率比较低，不能生成可独立执行的可执行文件，应用程序不能脱离其解释器。如Python、Java、PHP、Ruby等。跨平台性好、开发效率不高。

编译型语言执行速度快，不依赖语言环境运行，跨平台差
解释型跨平台好，一份代码，到处运行。缺点是执行速度慢，依赖解释器运行。

Python创始人：Guido van Rossum（龟叔）
Python诞生在1989年
2008年12月出现Python3.0
2010年出现一个过渡版本Python2.7（最多只支持到2020年,之后不支持2.0版本）

Python解释器是用C语言写的
Python解释器种类有：CPython、IPython、PyPy、Jython、IronPython

Python的安装：打开官网http://www.python.org/downloads/windows/下载中心

测试安装是否成功：
windows-->运行-->输入cmd,回车，弹出cmd程序，输入Python，如果进入交互环境，代表安装成功。

print('hello world!')
保存为helloworld.py,注意.py后缀名的作用：命名约束规范，方便程序员识别代码。
进入cmd命令行，执行Python helloworld.py,看结果。
注意文件名前面加python的原因是要把代码交给python解释器去解释执行

内存和磁盘的关系：内存存取速度快，断电就丢失；磁盘存取速度慢，永久保存。

Python交互器是主要用来对代码进行调试用的

变量：先定义后使用
变量作用：存数据，占内存，存储程序运行的中间结果，可以被后面的代码调用。

声明变量：变量名=变量的值

变量的命名规则：
1.变量名只能是数字、字母或下划线的任意组合
2.变量名的第一个字符不能是数字
3.以下关键字不能声明为变量名['and','as','assert','break','class','continue','def','elif','else','except','exec','finally','for','from','global','if','import','in','is','lambda','not','or','pass','print','raise','return','try','while','with','yield']

常量：程序在执行过程中不能改变的量
在Python中没有一个专门的语法代表常量，程序员约定俗成的变量名全部大写代表常量。

读取用户输入

name = input(" what's your name:") print("hello "+name)

输入用户姓名和密码

username= input("username:")

password= input("password:")

print(username,password)

注释:解释说明，帮助阅读代码。
单行注释：#
多行注释：'''....'''

数据类型
数据类型-数字类型

int（整型）：32位机器上：-2**31 —— 2**31-1 64位同样的道理
long（长整型）：Python的长整型没有指定位宽。（Python3里不再有long类型）
float（浮点型）：

数据类型-字符串类型
字符串：在Python中，加了引号的字符都被认为是字符串！
注意：单双引号是没有任何区别的；多行字符串必须用多引号。

布尔类型：
只有两个值True、False ，主要用来做逻辑判断

格式化输出：（%s 以一个字符替换 %d以一个整数替换 %f以一个浮点数替换）都是一个占位符 %是一个连接符

运算符
算术运算符（+,-,*,/,%,**,//），
比较运算符(==,!=,<>,>,<,>=,<=)，
逻辑运算符(and,or,not)，
赋值运算符(=,+=,*=,/=,%=,**=,//=)，
成员运算符(in,not in)，
身份运算符(is , is not)，
位运算(>>,<<)

流程控制

单分支：
if 条件：
　　满足条件后要执行的代码块

多分支：
if 条件：
　　满足条件后要执行的代码块
elif 条件：
　　上面的条件不满足就走这个
elif 条件：
　　上面的条件不满足就走这个
elif 条件：
　　上面的条件不满足就走这个
else:
　　上面的条件不满足就走这个

while循环

while 条件：
　　执行代码...

Dead Loop
count=0
while True:
　　print("你个基佬！！！",count)
　　count+=1

循环终止语句：break语句或continue语句
break语句：用于完全结束一个循环，跳出循环体执行后面的语句
continue语句：只终止本次循环，接着执行后面的循环

while...else用法
当while循环正常执行完，中间没有被break终止的话，就会执行else后面的语句。

二进制运算、字符编码、数据类型
二进制（0,1）、八进制（0-7）、十进制（0-9）、十六（0-9，A-F）进制的转换
四位二进制表示一位十六进制
oct() 八进制 hex()十六进制
char(num)将ASCII值得数字转换成ASCII字符，范围只能是0-255
ord(char)接受一个ASCII值字符，返回相应的ASCII值

每一位0或1所占的空间单位为bit(比特)，这是计算机中最小的表示单位
8bits = 1Bytes字节,最小的存储单位，1bytes缩写为1B
1024Bytes = 1KB = 1KB
1024KB = 1MB 
1024MB =1GB
1024GB = 1TB
1024TB = 1PB

ASCII 256，每一个字符占8位
Unicode编码(统一码、万国码):规定了所有的字符和符号最少由16位表示
UTF-8:ascii码中的内容用1个字节保存，欧洲的字符用2个字节保存，东亚的字符用3个字节保存...
winsows系统中文版默认编码是GBK
Mac OSLinux系统默认编码是UTF-8

UTF是为unicode编码 设计的一种在存储和传输时节省空间的编码方案。

无论以什么编码在内存里显示字符，存到硬盘上都是二进制。不同编码的二进制是不一样的
存到硬盘上以何种编码存的，那么读的时候还得以同样的编码读，否则就乱码了。

python2.x默认编码是ASCII；默认不支持中文，支持中文需要加：#_*_ coding:utf-8 _*_ 或者 #!encoding:utf-8
Python3.x默认编码是UTF-8，默认支持中文

Python数据类型
字符串 str
数字：整型（int）长整型(long) 浮点型(float) 布尔（bool） 复数（complex）
列表 list
元组 tuple
字典 dictionary
集合:可变集合(set) 不可变集合（frozenset）
不可变类型：数字，字符串，元组
可变类型：列表，字典，集合

 

字符串
特点：有序、不可变
字符串的常用方法:isdigit,replace,find,count,index,strip,split,format,join,center

s = "abcd"
print(s.swapcase())     #都变成大写字母

print(s.capitalize())   #都变成首字母大写

print(s.center(50,"*"))   #打印变量s的字符串 指定长度为50，字符串长度不够的用*号补齐

print(s.count("a",0,5))     #统计字符串a在变量里有几个；0,5代表统计范围是下标从0-5的范围

print(s.endswith("!"))      #是否是以什么结尾的。

print(s.startswith("a"))    #判断以什么开始


s = "a  b"
print(s.expandtabs(20))  #相当于在a和b中间的tab长度变成了20个字符，交互模式可看出效果

s.find("a",0,5)     #查找字符串，并返回索引

s.format()          #字符串格式化
s1 = "my name is {0},i am {1} years old"
print(s1)
print(s1.format("aaa",22))  #分别把{0}替换成aaa  {1}替换成22
#也可以写成如下
s1 = "my name is {name},i am {age} years old"
s1.format(name="aaa",age = 22)  #字典形式赋值

#s.format_map()  #后续补充


print(s.index("a"))     #返回索引值

print(s.isalnum())      #查看是否是一个阿拉伯字符 包含数字和字母

print(s.isalpha())      #查看是否是一个阿拉伯数字 不包含字母

print(s.isdecimal())    #判断是否是一个整数

print(s.isdigit())      #判断是否是一个整数

print(s.isidentifier())     #判断字符串是否是一个可用的合法的变量名

print(s.islower())      #判断是否是小写字母

print(s.isnumeric())    #判断只有数字在里边

print(s.isprintable())  #判断是否可以被打印，linux的驱动不能被打印

print(s.isspace())      #判断是否是一个空格

print(s.istitle())      #判断是否是一个标题   每个字符串的首字母大写  Hello Worlld

print(s.isupper())      #判断是否都是大写

# s.join()
name = ["a","b","1","2"]
name2 = "".join(name)   #列表转成字符串，把列表里边的元素都join到字符串中
print(name2)        #得出ab12

#s.ljust
s = "Hello World"
print(s.ljust(50,"-"))  #给字符串从左往右设置长度为50，字符串长度不够用 - 补充

print(s.lower())        #字符串都变成小写

print(s.upper())        #变大写

print(s.strip())        #脱掉括号里边的，可以是空格 换行 tab ...

s.lstrip()              #只脱掉左边的空格
s.rstrip()              #只拖点右边的空格

# s.maketrans()           #
str_in = "abcdef"       #必须是一一对应
str_out = "!@#$%^"      #必须是一一对应
tt = str.maketrans(str_in,str_out)  #生成对应表，就像密码表一样
print(tt)
#结果：{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}

print(s.translate(tt))  # s.translate方法调用 加密方法tt 给 s的字符串加密
#结果：H%llo Worl$

# s.partition()
s = "Hello World"
print(s.partition("o")) #把字符串用 从左到右第一个o把 字符串分成两半
#结果：('Hell', 'o', ' World')

s.replace("原字符","新字符",2)     #字符串替换，也可以写换几次 默认全换，可以设置count次数

s.rfind("o")       #查找最右边的字符，也有开始和结束

print(s.rindex("o") )   #查找最右边的字符的索引值

s.rpartition("o")       #从最右边的字符开始 把字符串分成两半

s.split()               #已括号里边的把字符串分成列表，括号里可以是空格、等字符来分成列表

s.rsplit()              #从最右边以 某字符 来分开字符串

s.splitlines()          #设置以换行的形式 把字符串分成列表

print(s.swapcase())       #字母换成相反的大小写，大的变成小，小的变成大
#结果“：hELLO wORLD
#原来的“hello World”

s.title()               #把字符串变成title格式  Hello World

s.zfill(40)             #把字符串变成40，字符串不够，从左往右用0 补齐


#"a	b"  字符串中间的	 被认为是tab 是4个或者8个空格
#整体意思是：a 有一个tab 然后 又有一个b

列表
列表的常用方法：创建、查询、切片、增加、修改、删除、循环、排序、反转、拼接、clear、copy
列表的特点：可以重复；列表是有序的

1、创建
​ 方法一：list1 = ["a", "b"]　　  # 常用
​ 方法二：list2 = list () 　　　  # 一般不用这种方法

2、查询
​ 列表的索引 (也称下标)：
列表从左到右下标是从0开始0、1、2、3....
​列表从右到左下标是从 - 1开始 -1 -2 -3...

​查询索引值：
​list1.index (a) 　　  # index查询找到第一个a程序就不走了，
list1[0] 　　  # 通过a的索引 得出a
list1[-1]　　  # 通过b的下标 得出b

当list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]
列表里出现元素相同时，统计相同次数
list1.count (4) 　　  # 统计得出:6   代表列表有6个4

3、切片
切片：通过索引 (或下标)
截取列表中一段数据出来。
list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]
list1[0:2] 　　  # 得出 [1,2] ，列表切片顾头不顾尾，也可成list1[:2]
list1[-5:] 　　  # 得出[4,4,4,4,4]，取最后5个元素，只能从左往右取
按步长取元素：
list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]
list1[:6:2] 　　  # 得出:[1, 3, 5] 　　:2 代表步长 ，每隔两步取一个元素
list1[::2] 　　  # 得出:[1, 3, 5, 1, 3, 5] 　在列表所有元素中，每隔2步取一个数

4、增加
list1 = ["a", "b", "c"]
list1.append ("d") 　　  # 追加d到列表list1的最后 结果:['a', 'b', 'c', 'd']
list1.insert (1, "aa") 　　  # 插入aa到列表下标为1的之前 　　得出结果:['a', 'aa', 'b', 'c', 'd']

5、修改
list1[1] = "bb" 　　  # 直接给对应位置赋值，即是修改 结果:['a', 'bb', 'b', 'c', 'd']
批量修改
把['a', 'bb', 'b', 'c', 'd']里的前两个元素替换掉
list1[0:2] = "boy" 　　  # 结果:['b', 'o', 'y', 'b', 'c', 'd']

6、删除
list1 = ['b', 'o', 'y', 'b', 'c', 'd']
list1.pop () 　　  # 默认删除最后一个元素 d
list1.remove ("o") 　　  # 删除元素O remove只能一个一个删除
list1.remove (0) 　　  # 删除下标为0的元素 b
del list1[0] 　　  # 删除下标为0的元素 del是一个全局删的方法
del list1[0:2] 　　  # del可以批量删除

7、for循环列表
list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]
for i in list1:  #使用for循环循环列表list1里边的元素
range (10) 　　  # 生成0到10 的数字

8、排序
list1 = ["1", "5", "3", "a", "b", "f", "c", "d", "A", "C", "B"]
list1.sort ()      #结果：['1', '3', '5', 'A', 'B', 'C', 'a', 'b', 'c', 'd', 'f']

排序是按照ASCII码对应排序。
反转
list1.reverse ()   #结果：['f', 'd', 'c', 'b', 'a', 'C', 'B', 'A', '5', '3', '1']

9、两个列表拼一块
# 方法一
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9]
list1 + list2    #结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
# ​方法二
list1.extend (list2) 　　  # 把列表2扩展到list1中
结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

10、clear
# 清空列表
list2.clear () 　　  # 清空list2

11、copy
浅copy
复制列表
list2 = list1.copy ()
当列表只有一层数据，没有列表嵌套列表的情况下，复制后的列表和原来的列表是完全独立的。
当列表有多层嵌套的时候，列表嵌套里边的列表的内容是和原有列表是共享的。
list1.copy () #所以这个叫做：浅copy

​深copy:需要借助python模块
import copy
list2 = copy.deepcopy (list1)
深copy后，新的列表和旧的列表，不管有没有列表嵌套列表，都是完全独立的个体。
可以通过查看列表名对应的内存地址分辨两个列表是否独立
查看python解释器里边的内存地址：id (变量名)

元组
特点：有序的，不可变的列表
常用功能：index,count,切片
使用场景：显示的告知别人，此处数据不可修改；数据库连接配置信息等

hash函数
hash，一般翻译为“散列”，也有直接翻译为“哈希”的，就是把任意长度的输入，通过散列算法，变成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不通的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
特征：hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变的。（不能保证输出的数据唯一的，容易造成冲突）
用途：文件签名；md5加密；密码验证

>>> hash("abc")
-6784760005049606976
>>> hash((1,2,3))
2528502973977326415

字典
语法：info={}
特点：1.key-value结构，key必须是可hash、必须是不可变数据类型、必须唯一
           2.每一个key必须对应一个value值，value可以存放任意多个值，可修改，可以不唯一
           3.字典是无序的
字典的查找速度快是因为字典可以把每个key通过hash变成一个数字（数字是按照ASCII码表进行排序的）
字典的方法：增删改查 多级嵌套 等

# 字典方法
info = { 
    "student01":"aaa" , 
    "student02":"bbb",
    "student03":"ccc"
}

# 增加
info["student04"] = "ddd"
info["student05"] = "eee"
info["student06"] = "fff"

# 查询
# 判断student01在不在info字典里
print("student01" in info    )   # 返回True
print(info.get("student01"))    # 返回aaa，没有返回None
info["student01"]   # 获取对应的value ，如果没有这个key 就报错，所以一般用get

# 删除
print(info.pop("student01"))  # 删除key
print(info.popitem())       # 随机删除一个key
del info["student02"]   # 删除的key ，如果没有删除的key 就报错 KeyError: 'student01'

info.clear()    # 清空字典

# 多级字典嵌套
dic1 = {"aaa": {"aa": 11}, "bbb": {"bb": 22}}

# 其他方法
info = {
    "name1": [22, "it"],
    "name2": [24, "hr"],
    "name3": 33
}

info2 = {
    "name1": 44,
    "name4": 33,
    1: 2
}
info.keys() # 打印所有的key
info.values()   # 打印所有的value
info.items()    # 把字典转成一个列表
info.update(info2)   # 把两个字典合成一个,如果有重复的key ，info2里边的重复key会覆盖info里边的key
info.setdefault("student07","abcdef")   # 设置一个默认的key:value ,
# 如果info字典里没有key student07 ，那么info字典里有添加 student07:abcdef
# 如果info字典里已经手动添加了student07的key value，那么这里的student07:abcdef 就不起作用
print(info.fromkeys(["name1","name2"],"aaa") )    # 从一个可迭代的对象中批量生成key和相同的value

# 字典的循环:高效循环
for k in info:
    print(k,info[k])    # 打印key value

# 另外一种方法 低效
for k,v in info.items():    # 先把字典转成列表，在循环，所以低效
    print(k,v)

集合
集合是一个无序的、不重复的数据组合
作用：1.去重
           2.关系测试，测试两组数据之间的交集、差集、并集等关系
语法：
s = {} #如果为空，就是字典
s = {1,2,3,4} #就成了集合 set
s = {1,2,3,4,1,2} #有重复数据，显示结果就直接去重{1, 2, 3, 4}

列表转成给一个字典
l = [1,2,3,4,1,2]
l2 = set(l)

集合的方法

#集合方法
s = {1,2,3,4,5}     #定义一个集合

#增加
s.add(6)
print(s)    #{1, 2, 3, 4, 5, 6}

#删除
#随机删除
s.pop()
print(s)    #{2, 3, 4, 5, 6}
#指定删除,如果不存在，就报错
s.remove(6)
print(s)    #{2, 3, 4, 5}
#指定删除，如果不存在，不报错
s.discard(6)
print(s)

#联合其他集合，可以添加多个值
s.update([7,8,9])
print(s)    #{2, 3, 4, 5, 7, 8, 9}

#清空集合
s.clear()


#集合的关系测试
iphone7 = {"alex","rain","jack","old_driver"}
iphone8 = {"alex","shanshan","jack","old_boy"}

#交集
print(iphone7.intersection(iphone8))
print(iphone7 & iphone8)
# 输出：
{'jack', 'alex'}
{'jack', 'alex'}

#差集
print(iphone7.difference(iphone8))
print(iphone7 - iphone8)
# 输出：
{'rain', 'old_driver'}
{'rain', 'old_driver'}

#并集 把两个列表加起来
print(iphone7.union(iphone8))
print(iphone7 | iphone8)
# 输出：
{'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}
{'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}

#对称差集   把不交集的取出来
print(iphone7.symmetric_difference(iphone8))
# 输出:
{'rain', 'old_driver', 'shanshan', 'old_boy'}

s = {1,2,3,4}
s2 = {1,2,3,4,5,6,}
#超集 谁是谁的父集
print(s2.issuperset(s))   #s2是s的父集
print(s2 >= s)
# 输出：
True
True

#子集
print(s.issubset(s2)) #s是s2的子集
print(s <= s2)
# 输出：
True
True

#判断两个集合是否不相交
print(s.isdisjoint(s2))
# 输出：
False    #代表两个集合是相交的

s = {1,2,3,-1,-2}
s2 = {1,2,3,4,5,6}
s.difference_update(s2)  #求出s和s2 的差集，并把差集 覆盖给 s
print(s)               # 结果：{-2, -1}

s.intersection_update(s2)    #求出s和s2的交集，并把交集 覆盖给 s
print(s)
print(s2)
# 结果:
{1, 2, 3}
{1, 2, 3, 4, 5, 6}

字符编码
python3
　　文件编码默认 ：utf-8
　　字符串编码：unicode
python2
　　文件编码默认：ascii
　　字符串编码默认：ascii
　　如果文件头声明了utf-8，那字符串的编码是utf-8
　　unicode是一个单独的类型

python3的内存里：全部是unicode
python3执行代码的过程：
1、解释器找到代码文件，把代码字符串按文件头定义的编码加载到内存，转成unicode
2、把代码字符串按照python语法规则进行解释
3、所有的变量字符都会以unicode编码声明

在python2里边，默认编码是ASCII编码，那么文件头声明是utf-8的代码，在windows中将显示乱码
如何在windows上显示正常呢？（windows的默认编码是gbk）
　　1、字符串以gbk格式显示
　　2、字符串以unicode编码
修改方法：
1.UTF-8 -- >decode解码 --> Unicode
2.Unicode -- > encode编码 -- > GBK / UTF-8

s="路飞学城"
print("decode before:",s)
s2=s.decode("utf-8")
print("decode after:",s2)
print(type(s2))
s3=s2.encoded("gbk")
print(s3)
print(type(s3))

python中bytes类型
二进制的组合转换成16进制来表示就称之为bytes类型，即字节类型，它把8个二进制组成一个bytes，用16进制来表示。
在python2里，bytes类型和字符串是本质上时没有区分的。
　　str = bytes
　　python2 以utf-8编码的字符串，在windows上不能显示，乱码。
　　如何在python2下实现一种，写一个软件，在全球各国电脑上 可以直接看？
　　　　以unicode编码写软件。

　　　　s = you_str.decode("utf-8")

　　　　s2 = u"路飞"

　　unicode类型 也算字符串
文件头：
python2：以utf-8 or gbk 编码的代码，代码内容加载到内存，并不会被转成unicode，编码依然是utf-8 或 gbk。
python3：以utf-8 or gbk编码的代码，代码内容加到在内存，会被自动转成unicode。

在python3里，bytes类型主要来存储图片、视频等二进制格式的数据
　　str = unicode
　　默认就支持了全球的语言编码

常见编码错误的原因有：
　　1、python解释器的默认编码
　　2、python源文件文件编码
　　3、终端使用的编码（windows/linux/os）
　　4、操作系统的语言设置