python基本数据类型

python有6种基本的数据类型： 数值 | 字典 | 集合 | 列表 | 元组 | 字符串
其中有五个容器： 字典 | 集合 | 列表 | 元组 | 字符串

数值型

空值为None 不是 0
 int、float、complex、bool

 序列对象

• 字符串 str
• 列表 list
• tuple

 键值对

• 集合set
• 字典dict

数字的处理函数
math模块、floor()地板、天花板ceil(）
公式：
*round()，四舍六入五取偶
floor()向下取整、
ceil()向上取整 
int() 取整数部分
divmod() 返回元组

// 整除且向下取整*

例子：
print(round(2.5), round(2.5001), round(2.6))
print(2//3, -2//3, -1//3)

type(obj) ，返回类型，而不是字符串

复数： z = a+bj a为实数部分，b为虚数部分

Python的列表

1. 一个队列，一个排列整齐的队伍
2. 列表内的个体称作元素，由若干元素组成列表
3. 元素可以是任意对象(数字、字符串、对象、列表等
4. 列表内元素有顺序，可以使用索引
5. 线性的数据结构
6. 使用 [ ] 表示

列表是 可变的

列表不能一开始就定义大小

---

列表索引访问

索引，也叫下标
正索引:从左至右，从0开始，为列表中每一个元素编号
负索引:从右至左，从-1开始
列表通过索引访问
list[index] ，index就是索引，使用中括号访问

列表查询
index(value,[start,[stop]])

通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
count(value)
返回列表中匹配value的次数

sir=[1,2,3,3,4]
sir.index(2) ;返回值为1 or sir.count(3) 返回值为2

列表元素修改

索引访问修改

list[index] = value
索引不能超界

列表增加、插入元素
append(object) -> None
列表尾部追加元素，返回None，返回None就意味着没有新的列表产生，就地修改
时间复杂度为O(1)

sir.append(1)

extend（）
extend（）对于列表的操作主要实现的是对于特定列表的扩展和增长，可以一次添加多个元素，不过也只能添加在列表的最后；

sir.extend([5,2,0])

insert(index, object) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改  时间复杂度是O(n)
索引能超上下界吗?
超越上界，尾部追加
超越下界，头部追加

sir.insert(0,5) #在头部插入5

• * -> list
   重复操作，将本列表元素重复n次，返回新的列表

x = [[1, 2, 3]]3 答案是：[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
x[0][1] = 20 #将x[0]的中间替换成20 就是2换成20
print(x)
虽然列表相很方便，但是容易掉 会出现的坑在：

ll = [{'a':1}] * 4
ll[0]['a']=222
print(ll) # 会出现全部修改的，没有单独的修改
--- 改进，可以单独修改
l = [{'a':1} for _ in range(4)] # 列表解释式
print(l)
l[0]['a'] = 222
print(l)

列表删除元素

remove(value) -> None
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改,时间复杂度为O（n）不建议使用

pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误  效率?指定索引的的时间复杂度?不指定索引呢?
clear() -> None
清除列表所有元素，剩下一个空列表

列表其它操作

排序，反转

 @staticmethod
    def sort(item: list, reverse=False):
        newlist = []
        for i in item:
            for j, v in enumerate(newlist):
                order = i > v if reverse else i < v
                if order:
                    newlist.insert(j, i)
                    break
            else:
                newlist.append(i)
        return newlist

切片
Temp=m[A:B] %表示将m列表里从索引号位置为A开始的元素到B-1处元素之间的列表获取赋给temp.

1. m.count(A)：输出元素A在列表m里面出现的次数

     2）m.index(A)：输出元素A在列表m里面的索引位置号

m.index(A,a,b)：对于列表m里面包含多个元素A时，输出在列表m索引号a-b之间的特定索引号

3）m.reverse()：将列表m进行前后的翻转，前变后，后变前

4）m.sort()：将列表m里面地数据进行从小到大的排列

浅复制
lst5 = lst0.copy()

# 浅复制没有遇到引用地址的时候还是可以用的
lst = [1,2,3]
lst1 = lst.copy()
print(lst1)
print(id(lst), id(lst1))
lst[1] = 5
print(lst)
print(lst1)

---

# 浅复制遇到引用地址，就会随着引用地址的值改变而改吧
lst = [1,[2,4],3]
lst1 = lst.copy()
print(lst1)
print(id(lst), id(lst1))
lst[1][1] = 5
print(lst)
print(lst1)

深复制
lst5 = copy.deepcopy(lst0)

# 深拷贝 整个拷贝
import copy
lst = [1,[2,4],3]
lst1 = copy.deepcopy(lst)
print(lst1)
print(id(lst), id(lst1))
lst[1] = 5
print(lst)
print(lst1)

**

元组 tuple

**
列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。
Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

使用 小括号 ( ) 表示

t = (1,) # 一个元素元组的定义，注意有个逗号
t = (2,4,6,3,4,2)
t = (1,2,3) * 6

tuple[index] ，index就是索引，使用中括号访问
index # 匹配第一个就立即返回索引
count #返回列表中匹配value的次数
len(tuple) #返回元素的个数
元组是只读的，所以增、改、删方法都没有
虽然不能修改元组的元素，但可以给存储元组的变量赋值。
命名元组

from collections import namedtuple
student=namedtuple('student','name,age,sex')
spark=student(name='sunYang',age=20,sex='male')
print(spark)
print(spark.name)
print(spark.age)

---

字符串

**
字符串是 不可变 对象
字符串支持使用索引访问
可迭代
+ -> str
将2个字符串连接在一起,返回一个新字符串

字符串分割
split系 #字符串按照分隔符分割成若干字符串，并返回列表
partition系 # 将字符串按照分隔符分割成2段，返回这2段和分隔符的元组

s1.split() #把S1里面的字符空格全去掉
s1.split(‘s’) #把找到的第一个去掉
lstrip(从左向右) 和strip() ,rsplit(从右向左)

字符串大小写

upper() 全大写
lower() 全小写
大小写，做判断的时候用
swapcase() 交换大小写

字符串排版

title() -> str
标题的每个单词都大写
capitalize() -> str 首个单词大写
center(width[, fillchar]) -> str

width 打印宽度
fillchar 填充的字符

zfill(width) -> str

width 打印宽度，居右，左边用0填充
ljust(width[, fillchar]) -> str 左对齐

字符串修改*

replace(old, new[, count])

字符串中找到匹配替换为新子串，返回新字符串，count表示替换几次，不指定就是全部替换

‘www.baidu.com’.replace(‘w’,‘p’,2) #把W换成P，进行两次

字符串判断 is系列
isalnum() -> bool 是否是字母和数字组成  isalpha() 是否是字母
isdecimal() 是否只包含十进制数字
isdigit() 是否全部数字(0~9)
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线 islower() 是否都是小写
isupper() 是否全部大写
isspace() 是否只包含空白字符

---

bytes、bytearray

字符串与bytes
字符串是字符组成的有序序列，字符可以使用编码来理解
bytes是字节组成的有序的不可变序列
bytearray是字节组成的有序的可变序列

**

线性结构

**
可迭代 for … in
len()可以获取长度
通过下标可以访问
可以切片

列表、元组、字符串、bytes、bytearray

切片是可以赋值的

b[:] = a #等于创建了两个表

**

set 集合

为 { }
可变的、无序的、不重复的元素的集合
set 的元素要求必须可以 hash

元素不可以使用索引
set 可以迭代

add(elem)
增加一个元素到set中
如果元素存在，什么都不做
update(*others)
合并其他元素到set集合中来
参数others必须是可迭代对象 就地修改

set删除
remove(elem)
从set中移除一个elem元素,元素不存在，抛出KeyError异常
discard(elem)
从set中移除一个elem元素 元素不存在，什么都不做
pop() -> item #随意弹出一个数，移除并返回任意的元素。

set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关
可hash
 数值型int、float、complex
 布尔型True、False
 字符串string、bytes
 tuple
 None
 以上都是不可变类型，是可哈希类型，hashable

set的元素必须是可hash的

并集 A ∪ B
两个集合A和B的所有的元素合并到一起，组成的集合称作集合A与集合B的并集
union(*others)
返回和多个集合合并后的新的集合

交集 A & B
集合A和B，由所有属于A且属于B的元素组成的集合

差集 A -B
集合A和B，由所有属于A且不属于B的元素组成的集合

对称差集 A^B
集合A和B，由所有不属于A和B的交集元素组成的集合，记作(A-B)∪(B-A)

集合操作 set1 | set2 并集or 、 set1 & set2 交集 and 、 set1 ^ set2 对称差分 、 set1 - set2 差补

字典

1. key-value键值对的数据的集合
2. 可变的、无序的、key不重复

遍历：

for k, v in dict.item() # 键-值对
# 遍历键
1. for k in dict
2. for v in dict.keys()
3. sorted(dict.keys) # 键值排序

# 剔除重复项
for v in set(dict.values()) # 值