python基础复习-1-2 数据类型-strlisttupledict

Posted 2020-10-16 考鸡蛋

数据类型

数字

引号：
    123  数值
    ‘123‘ 字符串
    
整数：ini long   范围：（-2**31 - 2**31）
        num = 123
    长整型 long  (L)
        num = 123L
浮点型：float

复数型：

序列

字符串、列表、元组都属于序列

序列的两个主要特点是索引操作和切片操作

• 索引操作可以从序列中抓取一个特定的项目
• 切片操作可以从序列中获取一个切片，即序列的一部分

序列的基本操作

• len() : 求序列的长度
• • : 连接两个序列
• • : 重复序列元素
• in : 判断元素是否在序列中
• max() ; 返回最大值
• min() ; 返回最小值
• cmp(x,y): 比较两个序列是否相等

字符串 str

字符串：
    str = ‘this is a string‘      单引号
    str = "this is a strting"     双引号
    str = ‘‘‘this is a string‘‘‘  三引号
    str = """ this is a strtng """
    
    单双引号在python下没有区别
    三重引号 除了能定义字符串(可包含换行符)  还可以用作注释

切片

适用于所有序列
```
In [9]: a = ‘abcdef‘

In [10]: a[0:2]
Out[10]: ‘ab‘
取下标0到2 下标为2的不显示
In [11]: a[:2]
Out[11]: ‘ab‘
取下标0到2 下标为2的不显示
In [12]: a[:-1]
Out[12]: ‘abcde‘
取下标0到倒数第1个 下标为倒数第1个的不显示
In [13]: a[::2]
Out[13]: ‘ace‘
步长为2，即取下标为0、2、4、6
In [14]: a[-3:-1]
Out[14]: ‘de‘
从倒数第3个取到倒数第1个，倒数第1个不显示
In [15]: a[-1:-4:-1]
Out[15]: ‘fed‘
反向切片，从倒数第一个取到倒数第4个，倒数第4个不显示
In [16]: a[-1:-4:-2]
Out[16]: ‘fd‘
反向切片，从倒数第一个取到倒数第4个，步长为2
```

总结：
a = "abcdef"

a[A:B:C]

A:切片开始的下标，包含
B:切片结束的下标，不包含
C:正数时表示步长
  负数时表示进行反向切片及步长
  

元组 tuble

• 元组和字符串一样是不可变的
• 元组可以存储一系列的值
• 元组通常肜在用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变

定义元组;

t = tuble() 定义一个元组 多个元素用 ，号分格，元素可以是数字、字符串、列表、元组
t = (1,) 当只有一个元素时，需要加一个 ，号，不加则赋值为数字
t = （） 定义一个空的元组

元组的拆分：
t = (1, 2, 3)
a, b, c = t 将元组的值 1， 2， 3 依次赋值给 a, b, c

方法：

count() 统计元素在元组中的个数
index() 返回元素中元素第一个出现在下标

列表 list

• 列表是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目
• 列表是可变类型的数据
• 创建列表

list1 = [] 创建一个空列表

list2 = list() 使用list方法

list3 = [‘a‘, 1, [‘a‘, 1]]

方法：

• append() 追加

  L.append(object) -- append object to end

• del list[n] 根据下标删除某个元素

• remove() 删除列表里第一个出现在元素

  L.remove(value) -- remove first occurrence of value.

• insert() 在某个场索引前插入一个元素

  L.insert(index, object) -- insert object before index

• sort() 给列表陫序

  L.sort(cmp=None, key=None, reverse=False) -- stable sort IN PLACE;

  cmp(x, y) -> -1, 0, 1

• reverse() 反转

  L.reverse() -- reverse *IN PLACE*

• pop() 删除并返回指定下标的元素值，不指定默认删除最后一个

  L.pop([index]) -> item -- remove and return item at index (default last).

• extend() 通过附加迭代元素来扩展列表
  extend list by appending elements from the iterable

字典

• 字典是python中唯一映射的类型（哈希表）
• 字典对象是可变的，但字典的键必须是不可变的对象，一个字典中可以使用不同类型的键值
• 创建字典

dict1 = {} 使用 {} 创建一个空字典

dict2 = {‘name‘:‘li‘, ‘age‘:10}

dict3 = dict([(‘name‘,‘li‘),(‘age‘, 10)])

dict4 = dict(‘a‘=10, ‘n‘=100)

• 字典的方法：

• keys() 获取所有key

  D.keys() -> list of D‘s keys

• values() 获取所有 values

• D.values() -> list of D‘s values

• get() 获取key对应的值，不存在时可指定输出，默认为空

  D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

• has_key() 查看key是否存在

  D.has_key(k) -> True if D has a key k, else False

• iitems() 转换为以（key, value）组成的列表

  D.items() -> list of D‘s (key, value) pairs, as 2-tuples

• copy() 拷备

  D.copy() -> a shallow copy of D

• clear() 清空字典

  D.clear() -> None. Remove all items from D

• pop() 删除指定KEY的value并返回value,如果KEY不存在可以返回一个给定value,否则抛出导常

  D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  If key is not found, d is returned if given, otherwise KeyError is raised

• update() 从字典或两个迭代对象更新字典

  D.update([E, ]**F) -> None. Update D from dict/iterable E and F.

  If E present and has a .keys() method, does: for k in E: D[k] = E[k]

  If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v

  In either case, this is followed by: for k in F: D[k] = F[k]

• fromkeys() 使用序列生成一个字典，值默认为空，可指定

  dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  v defaults to None.