python 数据结构

一，数字类型

1.1 int整型

1.1.1 作用

用来记录人的年龄，出生年份，学生人数等整数相关的状态

1.1.2 定义

age = 18

1.2 float 浮点型

1.1.1 作用

用来记录人的身高，体重，薪资等小数相关的状态

1.1.2 定义

height=172.3

1.1.3 使用

加减乘除

1.1.4 区别

整数时精确的
浮点可能有四舍五入的误差

1.3 数据类型转换

# 进制转化
#十 --> 二 [0b]  
bin(3) -->  '0b11'
逆 int('0b11',3)  -->3
#十 --> 八 [0o]
oct(9) -->  '0b11'             
逆 int('0b11',9)  -->9
#十 --> 十六 [0x]
hex(16) -->  '0b11'
逆 int('0b11',17)  -->17

# 1.1 int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
s='123' ture
b='12.3' flause

1.4 使用：内置方法

加减乘除即可

二，字符串类型

2.1 作用

用来记录人的名字，家庭住址，性别等描述性质的状态

2.2 定义

name = 'Tony'
# “” ， ’‘ ， “”“ ”“” ， 都是一样的

2.3 类型转换

#所有数据都可以转化为字符类型
>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3)))  # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>

2.4 使用：内置函数

1，优先掌握

str = "0123456789"
#1. 索引取值
#1.1 正向取
str[1] = 1
#1.2 反向取 (没有0)
str[-1] =9 
#可以取值，但是不可以修改·····

#2. 切片(顾头不顾尾)
#2.1  顾头不顾尾
str[0:9] --> 012345678
#2.2 步长
str[0:9:2] --> 02468

#3. 长度
len(str) --> 10

#4. 成员运算 in 和 no in
'123' in str --> true
'321' no in str --> true

#5. strip 移除首尾指定字符（默认空格）
#5.1 不写，默认移除（空格，\n,\t）
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!
#5.2 指定
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony
>>> str2.lstrip('*')  #去除左边
tony**
>>> str2.rstrip('*')  #去除右边
**tony

#6 split
#6.1 不指定字符，默认空格
#6.2 指定

#7. 循环
for line in str #依次取出字符
	print（line）
    
0
1
。。。

2，需要掌握

  1. lower(), upper()
  2. startswith(), endswith()
  3. format（三种用法）
# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4  
'my name is tony, my age is 18!'

>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4  
'my name is tonytonytony, my age is tony!'

  1. spilt,rspilt

    1. 可以指定切割次数

  2. join

    # 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'

  3. replace

    1. replace("旧内容"，"新内容") --> replace("18","22")
    2. 可以指定替代几次

  4. isdigit

    1. 判断是否为纯数字，返回 true|false

3，需要了解

  1. find,rfind,index,rindex,count
  2. center,liust,riust,zfill
  3. expandtabs
  4. captalize,swapcase,title
  5. is数字系列
  6. is其他

三，列表 list

3.1 作用

记录一系列数据，同一范畴的数据。【 学生名字，学号】

3.2 定义

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

3.3 类型转换

#能被for循环遍历的类型都可以转化为for
#字符串 --> 字符数组
#字典 --> 只取key的值
#py3 优化依次排除。 py2 无序 [字典是无序的]
>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"jason","age":18}) #结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

3.3 使用

# 1. 简单的检索 s[0],s[1]..
# 2. 多维数组 
students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]

优先掌握

l = [1,'2',3]
#1、按索引存取值(正向存取+反向存取)：即可存也可以取      
#正向取
l[0]
#反向取
l[-1]
#可取可该 （不可存，用append）
l[2] = 3

#2、切片(顾头不顾尾，步长)
#切片就是拷贝行为   浅copy 不指向新地址
msg1="11223112"
msg= msg1[:]
print(id(msg))
print(id(msg1))
#3、长度
#4、成员运算in和not in

#5.1、追加
l.append()
#5.2 插入
l.insert(1,'len')   #在1前插入
#5.3 类表插入类表
l1= [1,2]  
l.extend(l1)  #(可循环的类型)

#6、删除
#6.1 del l[1]  
#公共的删除方法，没有返回值。
del l[1] 
#6，2  pop 根据索引删除
#默认删除最后的一个
l.pop[0]  #返回删除值
#6.3 remove（） 根据元素删除
l.remove('2')

#7、循环 (不要改in后面的内容)
for i in  l
	print i
del pop remove
索引 索引 元素
无 删除的元素 NULL

需要掌握的

  1. count
  2. index
  3. clear
  4. reverse
  5. sort

3.4 补充 队列，堆栈

#队列：frist in Frist ou ，先进先出 【FIFO】 吃了拉
l = []
#入队操作
l.append(1)
l.append(2)
l.append(3)
#出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

#堆栈 LIFO 后进先出   吃了吐
#入栈操作
l.append(1)
l.append(2)
l.append(3)
#出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

四，元组 (tuple)

"一个不可变的列表"

4.1作用

按照索引/位置存放多个值，只读不改

定义 ：（） ，分隔 多个任意类型的元素

t =(1, 2, '3')

是内存地址不变。

t=(0 --> 值 的内存地址，1 --> 。。。) 不可变

t= [1,[1,2]]
t[1][1] = 2  #是可变的

注意：

当元组中只有一个元素，必须加逗号。x= (1 , )

类型转换

>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)

内置方法

#1. 索引
#2. 切片
#3. 长度
#4. 成员运算in 
#5. 循环

#count
#index

五，字典 dict

5.1 作用

一一对应，key与value，提高检索效率。[key类型一致，value 类型随意]

5.2 定义 （key是不可变的，只保留一个）

{key ： value } 的形式

  1. 调用dict

    student =

  2. dict(x=1, x=2, x=3)

5.3 类型转换

# 转换1: 
info=dict([['name','tony'],('age',18)])
{'age': 18, 'name': 'tony'}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
#快速初始化的方式
d = {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

# 都是各种循环实现的。
# 特殊形式的特殊应用嘛

5.4 内置方法

优先掌握

# 1. 可修可改
# if key 不存在，则创建新字典

# 2. len  【key】
# 3. 成员运算 【key】

# 4. 删除
# 4.1 del
# 4.2 pop  
# 根据key删除，返回key对应的value
# 4.3 pop item
# 随机删，返回一个元组

# 5. key，value，items
# 这是py2 的，占空间。
d.key()      #返回 key列表
d.value()    #返回 value列表
d.items()    #返回 元组列表
# py3 中，拿到的都是老母鸡
# 要的for自取。每次循环取一个。
# 和py2 一样即 l = list(d.key())
# 6. 循环

需要掌握

  1. clear
  2. get
    1. 解决 key 不存在的问题
    2. 没有返回none
  3. setdefault
    1. d.setdefault('k1', '111')
    2. 如果k不在，就添加value，创建字典
    3. 如果k在，无操作
    4. 都返回 value。
  4. update
    1. 新字典更新老字典。新的追加到老字典。

基础使用

# 1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型
>>> person_info={'name':'tony','age':18,'height':185.3}
>>> person_info['name']
'tony'
# 2、字典可以嵌套，嵌套取值如下
>>> students=[
... {'name':'tony','age':38,'hobbies':['play','sleep']},
... {'name':'jack','age':18,'hobbies':['read','sleep']},
... {'name':'rose','age':58,'hobbies':['music','read','sleep']},
... ]
>>> students[1]['hobbies'][1] #取第二个学生的第二个爱好
'sleep'

总结区分：

  1. 存值个数
    1. 一个： 数字，字符串
    2. 多个： 类表，元组，字典
  2. 访问方式
    1. 直接访问： 数字
    2. 顺序访问：字符串，元组，列表
    3. key访问： 字典
  3. 可变不可变
    1. 可变： 列表，字典
    2. 不可变：数字，字符串，元组
posted on 2021-07-09 16:16  HermesBird  阅读(64)  评论(0)    收藏  举报
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3