python基础总结

数据类型

1.int整型

数字整数就是整型，支持加减乘除% ** += -= *= 等操作

int(66)

1.1独有功能

整型没有独有功能

定义形式就是在变量后面跟.功能

1.2共有功能

加减乘除等

1.3转换

bool转整型
int（true）#1
int(False)#0
字符串转整型
进制之间转换时需要借助10进制，10进制和其他进制之间可以互相转换，但是16 ，8 2，进制之间无法直接转换
int('0x101',base=16)#把字符串看作16进制，然后转换为16进制
int('186',base=10)#把字符串看作10进制，然后转换为10进制
int('0o10',base=8)#把字符串看作8进制，然后转换为8进制
int('ob10110',base=2)#把字符串看作2进制，然后转换为2进制

1.4其他知识

整型在python2和3中的区别

python2中int有整型（限制了长度）和长整型，长整型表示整型表示不了的数据

python3中int没有限制

python3中进行除法运算时得到的是具体的值

python2中除法运算默认得到整数//地板除

from __future__ import division
#引入此模块，在2中也可以得到具体的值

2.str字符串

字符串就是文本信息，必须用引号括起来,支持相加或者相乘

相加是将两个字符串拼接起来

相乘是将一个字符串重复多次

单行文本 #对于单行文本，可以使用单引号或者双引号括起来
print（'你好'）
多行文本
print（"""
白日依山尽
黄河入海流

"""）

2.1独有功能（18/48）

2.1.1判断字符串时候以XX开头，得到布尔值 .startswitch()

name="刘小流"
v2 = name.startswith("刘")
print（v2）True

2.1.2 判断字符串是否以XX结尾，得到一个bool值 .endswith()

2.1.3 判断字符串时候为10进制数，得到一个bool值.isdecimal()

​ 还有.isdigit() 此功能再判断时会把①此情况也判断为是10进制数

v1="123"
v2=v1.isdecimal()
print(v2)True

2.1.4 去除字符串两边的空格换行符制表符，得到一个新的字符串.strip()

.lstrip()去除左边的

.rstrip()去除右边的

需要去除指定内容是，再括号里面加上指定的内容既可

v1="   你好    "
v2=v1.strip()
print(v2)//你好

2.1.5字符串变的大写，得到一个新的字符串.upper（）

v1='abc'
v2=v1.upper()
print(v2)//ABC

2.1.6 字符串变小写，得到一个新的字符串.lower()

2.1.7字符串内容替换，得到一个新的字符串.replace()

v1='你好吗'
v2=v1.replace("好"："坏")
print（v2）//你坏吗

2.1.8 字符串切割，得到一个列表.split() #默认是从左边开始切割

从右边开始切割.rsplit()

从第几个符号开始切割.split('|',2) ，从左边第2个|切割

v1="你好|不好|好不"

v2=v1.split('|') #根据特定的字符进行切割，然后保存到列表中
print（v2） #["你好"，”不好“，”好不“]

2.1.9 字符串拼接得到新的字符串"符号".join() 指定使用某种符号进行拼接

data_list=["你"," 好"," 吗"]
v2="*".join(data_list)//将data_list列表使用*拼接起来
你*好*吗

2.1.10 格式化字符串得到新的字符串.format()

text="我叫{}，今年{}岁".format("小刘"，18)
text="我叫{0}，今年{1}岁".format("小刘"，18)
text="我叫{name}，今年{old}岁".format(name="小刘"，old=18)

2.1.11 字符串转换为字节类型.encode()

​ 字节转换为字符串.decode()

name="小刘"
v1=name.encode（"utf_8"）utf8是字节类型

v2=v1.decode("utf8")将utf8的字节转换为字符串

2.1.12 将字符串居中.center()

​ 居右.rjust()

​ 居左.ljust()

v1="小流域"
v2=v1.center(10,".."),总体长途10，将v1居中，不够的长度用..补全
v2=v1.ljust(10,"=") 小流域===========
v2=v1.rjust(10,"=") =======小流域

2.1.13 填充0.zfill()

data="alex"
v1=data.zfill(10) ,总长度为10不够用0填充到左边
000000alex

2.2公共功能

2.2.1 字符串相加+

2.2.2 字符串相乘

2.2.3获取长度 len()

v1="小刘"
v2=len(v1)

2.2.4 获取字符串中的字符，索引[]

​ 字符串只能同通过索引来取值，无法修改值，字符串在内部存储时不允许修改内部元素，只能重新创建

 v1="你还好把"
     0 1 2 3
  v1[0]  "你"

2.2.5 获取字符串中的子序列，切片[]

​ 前取后不取

​ 切片也是不能修改数据，只能读取

 v1="你还好把"
    0 1 2 3
    -4 -3 -2 -1
v1[0:2:2] 从0开始取，取到2结束不包括2，步长为2   得到 "你"
v1[2:-1]   "好"

2.2.6 循环

message = "来做点py交易呀"
index = 0
while index < len(message):
	value = message[index]
    print(value)
    index += 1
=========================================
message = "来做点py交易呀"
for char in message:
    print(char)
​			

2.2.7 range()可以创建一系列数字

range(10) [0,1,2,3,4,5,6,7,8,9]
range(1,10)[1,2,3,4,5....9]
range(1,10,2)[1,3,5,7,9]
range(10,1,-1)[10,9,8,7,6,5,4,3,2]

2.3转换

一般只有整型转字符串才有意义

3.bool布尔类型

布尔类型一共有两个值False True

3.1独有功能

没有

3.2公共功能

没有

3.3转换

经常会遇到其他类型转换为bool的场景，

0，空字符串，空列表，空元组，空字典，转换为bool是都为False，其他都是True

3.4其他知识

如果在条件语句的后面跟值的话，会先转换成bool类型再进行条件判断

4.list列表类型 []

列表list s是有序的可以变的容器，里面可以放多个不同类型的元素

4.1定义

不可变类型：字符串，布尔，整型（内部数据已经最小无法进行修改）

可变类型：列表（内部数据元素可以修改）

data_list=[1,2,3,'你','13']

4.2独有功能

4.2.1 追加，在列表的尾部追加值.append()

v1=[1,2,3,"你","dir"]
v2=100
v1.append(v2)             将v2的值追加到v1列表中 
v1=[1,2,3,"你","dir",100]

4.2.2 批量追加，将一个列表中的元素逐一加到零一个列表.extend()

v1=["ni","好","吗"]
v2=['很','好']
v1.extend(v2) 将v2中的值逐一加到v1中

4.2.3 插入，在源列表的指定索引位置插入值.insert()

v1=["ni","好","吗"]
v1.insert(0,"100") ["100","ni","好","吗"]在第0个索引插入

4.2.4 在原泪飙中根据值删除（从做到有删除），没有找到值会报错.remove()

v1=["ni","好","吗"]
v1.remove("好")

4.2.5在原列表中根据索引剔除某个元素（根据索引位置删除）.pop()

v1=["ni","好","吗"]
	0     1     2
v1.pop("1")

4.2.6 清空原列表.clear()

v1=["ni","好","吗"]
	0     1     2
v1.clear() 

4.2.7 根据值获取索引.index()

v1=["ni","好","吗"]
	0     1     2
v1.index(”好“)   1

4.2.8 列表元素排序.sort()

数字排序
num_list = [11, 22, 4, 5, 11, 99, 88]
num_list.sort()   让num_list从小到大排序
num_list.sort(reverse=True)  让num_list从大到小排序
字符串排序
# 字符串排序   是根绝
user_list = ["王宝强", "Ab陈羽凡", "Alex", "贾乃亮", "贾乃", "1"]
#       [29579, 23453, 24378]
#       [65, 98, 38472, 32701, 20961]
#       [65, 108, 101, 120]
#       [49]

4.2.9 反转列表.reverse()

v1=["ni","好","吗"]
	0     1     2
v1.reverse()   

4.3公共功能

4.3.1相加，两个列表相加可以生成一个新的列表相当于拼接起来

v1=[1,2,3]
v2=["比",'比']
v1+v2=[1,2,3,"比",'比']

4.3.2相乘，列表相乘，将列表中的元素再创建N份获得新的列表

v2=["比",'比']
v3=["比",'比']*2
["比",'比'，"比",'比']

4.3.3 成员运算符 in

列表内部是由多个元素组成的，可以通过in来判断元素是否再列表中

列表再检查元素是否存在的时候，是采用逐一比较的方式，效率比较低

user_list=[1,2,3,"比"]
v2= "比" in user_list
True

4.3.4 获取长度

user_list=[1,2,3,"比"]
print(len(user_list))
4

4.3.5 索引，针对一个元素的操作

超出索引位置会报错

查
user_list=[1,2,3,"比"]
			0 1 2 3
print(user_list[0]) 1
print(user_list[1]) 2
print(user_list[2]) 3

改
user_list=[1,2,3,"比"]
			0 1 2 3
user_list[0] = "你"      [你,2,3,"比"] 
删除

user_list=[1,2,3,"比"]
del user_list[1]

user_list.removep[1]

v1=user_list.pop[1]    

4.3.6 切片，根据索引对列表中的多个元素操作

前去后不取

查
user_list=[1,2,3,"比"]
print(user_list[0:2])     [1,2]

改
user_list[0:2]=[100,200]   [100,200.3,"比]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]
                            
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四'] 
                            
 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']    

4.3.7 步长

user_list=['你','好','吗','1',1]
			0   1    2    3   4
 user_list[1:3:2]  好  取索引1到3的值，隔2取1   
列表反转
user_list=['你','好','吗','1',1]
user_list[::-1]
或
user_list.reverse()

4.3.8 for 循环

user_list=['你','好','吗','1',1]
for i in user_list:    用i去游览列表中的元素
    print(i)
    
    
面试题
# 错误方式， 有坑，结果不是你想要的。

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
        
print(user_list)
正确方法
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

4.3.9 转换

• int bool类型无法转换为列表类型

• str转列表

  v1='你好吗'
  list(v1) ['你','好','吗']
  

• 元组和集合转换为列表

  v1=（11,12,13,145） 元组
  list(v1)   [11,12,13,145]
  
  v2 = {"alex","eric","dsb"}  集合
  vv2 = list(v2)  列表 ["alex","eric","dsb"]
  

  4.4 嵌套

  列表属于容器，内部可以存放各种数据，也可以支持列表的嵌套

  data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]
  

  嵌套值的索引

data = [ "谢广坤",["海燕","赵本山"],True,[11,22,[999,123],33,44],"宋小宝" ]
			0    1  0 1            2  3 0  1                      4
print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"

5.tuple元组类型 tuple（）

元组是一个有序且不可变的容器，里面可以存放多个不同类型的元素

不可变是指里面的元素不可以该百年，但是可以增加元素

如果元组只存放一个元素要在元组里面多加一个逗号，以表示这是一个元组

v1=(11,22,33)
v2=("alex","old")

v3=(1)   1
v4=（1，2） (1,2)

5.1独有功能

无

5.2公共功能

5.2.1 相加，两个元组相加获取一个新的元组

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")

5.2.2 相乘，列表相乘，将列表中的元素再创建N份并生成一个新的元组

data = ("赵四","刘能") * 2
print(data) # ("赵四","刘能","赵四","刘能")

v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

5.2.3 获取长度

data_list=(1,2,"刘","马")
print（len（data_list））

5.2.4 索引

索引元组里面没有的值会报错

data_list=(1,2,"刘","马")
		   0 1  2    3
data_list[0]

5.2.5 切片

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

5.2.6 步长

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )

5.2.7 for 循环

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
 if item == '刘华强':
	 continue
 print(name)

5.3转换

目前只有str和list可以转换为元组

name = "刘小刘"
v2 = [100]
v3 = tuple(name)
v4 = tuple(v2)  如果列表中只有一个元素的时候会自动加逗号
print(v3)
print(v4)
('刘', '小', '刘')
(100,)  

5.4 嵌套

6.dict字典类型{}

字典是无序，元素必须由键值对组成，键不可以重复，是可变的容器

无序在Python3.6字典就是有序了，之前的字典都是无序

v1={"name":'刘'"，"pw":"123"}
		   键  值
 

6.1定义

键：必须是可以哈希的 int bool str tuple

值：任意类型

v1={}
v1=dict()

6.2独有功能

6.2.1 获取值.get("键")

根据键，获取值

v1={"name":'刘'，"pw":"123"}
v2=v1.get("name")  刘
v3=v1.get("old")  None

6.2.2所有的键.Keys()

python3中获取键后返回的是高仿列表可以被循环

v1={"name":'刘'，"pw":"123"}
v2=v1.keys()  (["name","pw"])

6.2.3所有的键.values()

v1={"name":'刘'，"pw":"123"}
v2=v1.values()  (["刘","123"])

6.2.4所有的键值.items()

v1={"name":'刘'，"pw":"123"}
v2=v1.items()  ([('name'，'刘')，（'pw','123'）])

6.2.5 设置值.setdefault()

v1={"name":'刘'，"pw":"123"}
v1.setdefault("name1",'王')
{'name1':'王'，"name":'刘'，'pw'："123"}

6.2.6更新键值对.update({})

v1={"name":'刘'，"pw":"123"}
v1.update({"name"='王'，'six'=6})//没有的键直接添加进去，有的更新掉

6.2.7移除指定的键值对.po()

v1={"name":'刘'，"pw":"123"}
v1.pop=("name")//
{pw="123"}

6.2.8按照顺序移除，先移除后面的.popitem()

v1={"name":'刘'，"pw":"123"}
v2=v1.popitem()
{"name"='刘'}

6.3公共功能

6.3.1 求并集 |

6.3.2 求长度

v1={"name":'刘'，"pw":"123"}
v2=len（v1） #2
 

6.3.3 是否包含 in not in

v1={"name":'刘'，"pw":"123"}
v2= "pw" in v1   True

6.3.4索引，是对键操作[]

如果键 不存在的会报错

v1={"name":'刘'，"pw":"123"}
v1["name"] 刘

6.3.5根据键，修改值，添加值，删除键值对

v1={"name":'刘'，"pw":"123"}
v1["old"]=16  {"name":'刘'，"pw":"123"，'old':16}
v1['name']= "王"
del  v1[name]

6.3.6 for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

info = {"age":12, "status":True,"name":"武沛齐"}
for key,value in info.items():
#   键    值
	print(key,value)

6.4转换

v1=dict([("name","v2"),["A","B"]])
{'name':"v2","A":"B"}

7.set集合类型{}

无需不允许出现重复的值，可变类型，集合的元素必须要可哈希

不能通过所以索引取值

可以添加删除元素

不允许元素重复

用在维护数据量大且不重复的场景，如爬虫，避免找到重复的数据

data_set{11,12,13}
定义空集合的时候 v1=set() 不能v1={}这样是定义一个空字典

7.1 独有功能

7.1.1添加元素.add()

data={"刘"，"王"，"李"}
data.add("孙")  {"刘"，"王"，"李","孙"}

7.1.2 删除元素.discard()

data={"刘"，"王"，"李"}
data.discard("王")   {"刘"，"李"}

7.1.3交集 .intersection()

取两个集合都有的元素

data={"刘"，"王"，"李"}
name={"刘"，"孙"，"子"}
v1=data.intersection(name)
v1=data & name

7.1.4并集.union()

取两个结合的并集

data={"刘"，"王"，"李"}
name={"刘"，"孙"，"子"}
v1=data.union(name)  # {"刘"，"王"，"李","孙"，"子"}

7.1.5差集.difference()

data={"刘"，"王"，"李"}
name={"刘"，"孙"，"子"}
v1=data.difference(name)    data中有但是name中没有的值 {“王“，”李”}
v1=data - name

7.2公共功能

7.2.1 计算差集

7.2.2 计算交集

7.2.3 计算并集

7.2.4 计算长度

data={"刘"，"王"，"李"}
v1=len(data)

7.2.5 for循环

v = {"刘能", "赵四", "尼古拉斯"}
for item in v:
	print(item)

7.3转换

在转换的时候用set包裹一下就可以，并且数据如果有重复会自动删除

int list tuple dict str 都可以转换为集合

v1 = "刘小刘"
v2 = set(v1)
print(v2) # {"刘","小","刘"}

v1 = [1,2,1,4,5,5]
v2 = set(v1)
print(v2) # {1,2,4,5}

v1 = (1,2,3,4)
v2 = set(v1)
print(v2) # {1,2,3,4}

7.4嵌套

7.4.1集合的存储原理

第一步，将存储的数据转换为一个数值，

第二步，取余数

第三步，将存储的数据放在余数的索引位置

7.4.2 元素必须可哈希

集合的元素必须和哈希，内同通过哈希函数把值转换成一个数字

可哈希的数据类型有 int bool str tuple 不可哈希的有list set

7.4.3对比和嵌套

True和False本质上存储的是 1 和 0 ，集合又不允许重复，所以在整数 0、1和False、True出现在集合中会去重复

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	是	否	可哈希	否	set(其他)	v=set()

8.float 浮点类型

4.类型之间的转换

想转换成什么数据类型就用什么类型的英文表示进行包裹

字符串转换整型时只支持数字类型的文本进行转换

0，空字符串，空列表，空元组，空集合，空字典，转换为bool时为false，其他转换为bool都为True

str='666'
int(str)

5.变量名的规范

数字字母和下划线组成

不能数字开头

不能是python的内置关键字

建议：

下环线连接命名

见明知意

6.内存的指向关系//后面补充

8.None类型

python数据类型中有一个特殊的值None,表示为空

9.输入

输入可以实现程序和用户之间的交互

*输入的任何内容实际上都是字符串类型的

name=input('请输入你的名字：')

10.条件语句//补充10086练习

注意缩进的问题，4个空格

if 条件：
	成立执行的代码
else：
	不成立执行的代码

多条件判断
if 条件1 ：
	成立指向的代码
elif 条件2：
	条件2成立后指向的代码
else：
	都不成立后执行的代码

#多条件嵌套
10086
print（'欢迎拨打10086'）

11.循环语句

1.while循环

while 条件：
	条件成立进入此循环，直到条件不成立的时候结束循环
    或者循环中遇到break 则直接退出循环往下执行
    当遇到contine时则推出本次循环，开始下一次循环
 
#举例
while True：  # 死循环，因为条件一直成立
	print（'你好'）、
    break
print（'结束'）
#
你好
结束

2.while else

当while后的条件不成立的时候，else中的代码就会执行

while 条件：
	代码
else：
	代码

3for循环

目前只有list str tuple可以被for循环

12.字符串格式化

1.%进行格式化

有百分比的情况需要输入两个%%，以表示这是一个百分比

text = "%s，这个片我已经下载了90%%了，居然特么的断网了" %"兄弟"
print(text)

text="我叫%s，今年%d岁"%（"小刘"，18）
我叫小刘，今年18岁
# %s用与给字符串进行占位，%d给整型占位
text="我叫%（name）s，今年%（old）d岁"%（"name"："小刘"，"old":18）
我叫小刘，今年18岁

2..format()

text="我叫{}，今年{}岁".format("小刘"，18)
text="我叫{0}，今年{1}岁".format("小刘"，18)
text="我叫{name}，今年{old}岁".format(name="小刘"，old=18)

3.f

name="小刘"
old=18
tetx=f"我叫{name}，几年{old}岁"

13.运算符day03笔记

1.算数运算符

加减乘除 % ** //(返回商的整数部分)

2.比较运算符

大于 小于 != == >= <=

3.赋值运算符

= += -= *= /= %=

4.成员运算

in 在里面，如果在就返回True 不在返回False ，X in Y ，x是否在y里面

not in 不在里面，如果不在就返回True ，在就返回False ，X not in Y ，x不在Y里面

5.逻辑运算

and 与，都为真时则为真，有一个假则为假

or 或，有一个为真则为真

not 非，not（true）就是False

6.运算符的优先级

算数>比较>逻辑>not>and>or

有括号的时候括号优先级最大

14.注释

注释的内容，解释器会忽略不会执行

# 单行注释

”“”
多行注释
多行注释
“”“