python基础--数据类型

 1.python的数据类型 

基本类型：数字（整数int, 长整型long,浮点数float）

　　　　   字符串（文本str，字节bytes）

                 布尔（True/False)

数据集：列表list    元组tuple   字典dict(有序字典，无序字典）  集合set（有序，无序）

 

浮点数和科学计数法：1.399e3  ==  1,399 x 10³

浮点数就是有限小数或者无限循环的有理数小数。

## 列表list

列表是一个数据集合，可以存放任何类型的可重复数据。可以对集合进行方便的增删改查操作

• 创建列表

L1 = []   或者  L1 = list()   --- 空列表

L2 = ['a','b','c']

L3 = ['a','b',['c','d']]

• 查询列表

#利用索引查询
>>> L1 = ['a','b','c','d','louis']
>>> L1[0]                             
'a'
>>> L1[-1]
'louis'

#查询某个值得索引值，从左到右匹配第一个值
 >>> L1.index('louis')
 4

# 计算某个元素的个数
>>> L1.count('louis')
1

• 列表切片

>>> L1
['a', 'b', 'c', 'd', 'louis', 'louis', 'a', 'b', 'c', 'saint']
>>> L1[0:3]
['a', 'b', 'c']

>>> L1[-5:-1]          # 顾头不顾尾
['louis', 'a', 'b', 'c']

>>> L1[-5:]             # 可以全部取到
['louis', 'a', 'b', 'c', 'saint']

>>> L1[1:7:2]         # 步长为2
['b', 'd', 'louis']

>>> L1[::2]
['a', 'c', 'louis', 'a', 'c']

•  列表修插入

>>> L2
['math', 'english', 'work']
>>> L2.insert(1,'hh')
>>> L2
['math', 'hh', 'english', 'work']
>>> L2.insert(3,'lucy')

• 列表修改

>>> L2[0] = 'phy'
>>> L2
['phy', 'hh', 'english', 'lucy', 'work']
>>> L2[3] = 'oxygen'

# 批量修改
>>> L2[0:2] = ['louis','ll','kk']
>>> L2
['louis', 'll', 'kk', 'english', 'oxygen', 'work']

•  列表删除

>>> L1
['a', 'b', 'c', 'd', 'louis', 'louis', 'a', 'b', 'c', 'saint', 'kitty']
>>> L1.pop()
'kitty'
>>> L1.remove('a')  #有重复的就从左到右
>>> del L1[3]
>>> L1
['b', 'c', 'd', 'louis', 'a', 'b', 'c', 'saint']
>>> del L1[3:6]
>>> L1
['b', 'c', 'd', 'c', 'saint']

• 列表循环排序

>>> for i in L1:
... print (i)
...

b
c
d
c
saint

for b,n in enumerate(names):
    print (b,n)

>>> n = ['f','A','d','#','%']
>>> n
['f', 'A', 'd', '#', '%']
>>> n.sort()
>>> n
['#', '%', 'A', 'd', 'f']

>>> n.reverse()
>>> n
['f', 'd', 'A', '%', '#']

>>> n
[23, 3232, 23, 3232]
>>> n2 = ['fds','fds','dd']
>>> n2 + n
['fds', 'fds', 'dd', 23, 3232, 23, 3232]

>>> n.extend(n2)
>>> n
[23, 3232, 23, 3232, 'fds', 'fds', 'dd']

>>> n.clear()
>>> n
[]

• 列表的深浅copy

# 直接赋值 相当于共用一块内存，里面的值修改了一起变化。
>>> L1 = ['louis','lecy','cindy']
>>> L2 = L1
>>> id(L1),id(L2)
(2286598199304, 2286598199304)
>>> L1[0] = 'Oceaon'
>>> L1
['Oceaon', 'lecy', 'cindy']
>>> L2
['Oceaon', 'lecy', 'cindy']
# 浅copy
>>> L3 = L1.copy()
>>> id(L1),id(L3)
(2286598199304, 2286599523592)
分别属于不同的内存。但是如果里面有子列表的话就和直接赋值的一样，共用同一子列表，同时变化。

 ## 字符串

特点：有序，不可变

>>> s = "Fucking  Life"
>>> s.swapcase()
'fUCKING lIFE'
>>> s.capitalize()
'Fucking life'
>>> s.casefold() # 不区分大小写
'fucking life'
>>> s.center(20,'#')
'####Fucking Life####'
>>> s.count('i')
2
>>> s.count('i',0,5)
1
>>> s.endswith('e')
True
>>> s.find('F') # 找到一个值得索引
0
>>> s.find('l') # 没有返回负数
-1
>>> s.find('L',0,14)
8
>>> name = "I am from the {0},Life is {1}"  # 格式化
>>> name.format('ocean','pointless')
'I am from the ocean,Life is pointless'
>>> s2.format(sea = "ocean",age=22）

>>> names
['louis', 'hls', 'dds']

>>> '--'.join(names)
'louis--hls--dds'

replace  strip  split 等都是常用的方法

## 元组 tuple

元组是不可变得只读列表，但是里面如果有列表元素得部分则可以修改。

>>> names = ('louis','ocean','sailing')

应用场景：

1. 显示的告诉别人，此处不可修改。
2. 连接数据库的配置信息等

Hash：

把任意长度的输入，通过散列算法，变成固定长度的输出-- 散列值
这种算法是一种压缩映射。散列值的空间通常小于输入的空间，不同的输入可能散列成相同的输出。所以不能从散列值来唯一确定输入值。
hash 的用途：
1.文件签名
2.md5加密（无法反解）
3.密码验证（数据库中的密码是以密文的形式存放的）

## 字典

• 字典的特性

1. key-value 的数据类型
2. key必须可hash，必须为不可变得数据类型，必须唯一
3. value 可以存放多个值，可修改，可以不唯一
4. 无序，查找速度快（将key hash后查找速度特别快）

• 字典的方法

>>> info
{'name': 'louis', 'gender': 'male'}
>>> info['name']
'louis'
>>> info['name'] = 'saint'
>>> info
{'name': 'saint', 'gender': 'male'}

# 如果不存在也不会报错
>>> info.get('name')
'saint'
# 删除一个值
>>> info.pop('name')
'saint'
>>> info
{'gender': 'male'}
# 随机删除
>>> info.popitem()
(2, 'oo')

>>> info.keys()
dict_keys(['gender', 1])

>>> info.values()
dict_values(['male', 'kk'])

>>> info.items()
dict_items([('gender', 'male'), (1, 'kk')])

# 如果有key 值则覆盖，没有就创建
>>> dd
{1: 'dd', 2: 'louis', 'job': 'HR'}
>>> info.update(dd)
>>> info
{'gender': 'male', 1: 'dd', 2: 'louis', 'job': 'HR'}

# 如果有则不变，没有就追加
>>> info.setdefault(3,'app')
'app'
>>> info
{'gender': 'male', 1: 'dd', 2: 'louis', 'job': 'HR', 3: 'app'}

>>> info.fromkeys(['a','b'],'c')
{'a': 'c', 'b': 'c'}

# 字典的循环
>>> for k in info:
...     print (k,info[k])
...     
gender male
1 dd
2 louis
job HR
3 app

>>> for k,v in info.items():
...     print (k,v)

 

## 集合

集合是无序不重复的
>>> s = {2,3,12,3,3}
>>> s
{2, 3, 12}
>>> type(s)
<class 'set'>

# 将列表转换成集合
>>> I7
['alex', 'shanshan', 'jack', 'louis']
>>> s = set(I7)
>>> s
{'shanshan', 'louis', 'jack', 'alex'}

# 集合的方法
s.add   s.pop   s.remove(value)  s.discard(value) 如果不存在也不报错
s.update()  s.update(s1) # 跟list 和 dic 的update 是一样的
s.clear()

# 集合关系测试
>>> s7
{'shanshan', 'louis', 'jack', 'alex'}
>>> s8 = set(I8)
>>> s8
{'louis', 'linlin', 'alex'}

>>> s7.intersection(s8) #7 有 8 没有的
{'louis', 'alex'}
>>> s7.difference(s8)
{'jack', 'shanshan'}

>>> s7.union(s8)
{'jack', 'alex', 'linlin', 'shanshan', 'louis'}

>>> s7.isdisjoint(s8)
False

>>> s7.issubset(s8)
False
>>> s7.issuperset(s8)
False

---

## 十六进制

>>> hex(15)
'0xf'
>>> hex(16)
'0x10'
可以用ox 前缀表示 或者 H 后缀表示16 进制

使用十六进制：更简短。换算时一个16进制位可以顶4个二进制位，一个字节只需要用两个十六进制数表示就可以。

十六进制的使用场景：
网络编程：数据交换时需要对字节进行解析，都是一个字节一个字节的处理。通过网络抓包，可以看出数据是通过16进制传输的。

数据存储：在内存中解析时习惯使用16进制。

二进制和十六进制转换时 每四个 二进制转换成一个十六进制数。