1. 列表、元组操作

列表是我们最以后最常用的数据类型之一,通过列表可以对数据实现最方便的存储、修改等操作

定义列表

  1. names = ['Alex',"Tenglan",'Eric']

通过下标访问列表中的元素,下标从0开始计数

  1. >>> names[0]
  2. 'Alex'
  3. >>> names[2]
  4. 'Eric'
  5. >>> names[-1]
  6. 'Eric'
  7. >>> names[-2] #还可以倒着取
  8. 'Tenglan'

切片:取多个元素

  1. >>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
  2. >>> names[1:4] #取下标1至下标4之间的数字,包括1,不包括4
  3. ['Tenglan', 'Eric', 'Rain']
  4. >>> names[1:-1] #取下标1至-1的值,不包括-1
  5. ['Tenglan', 'Eric', 'Rain', 'Tom']
  6. >>> names[0:3]
  7. ['Alex', 'Tenglan', 'Eric']
  8. >>> names[:3] #如果是从头开始取,0可以忽略,跟上句效果一样
  9. ['Alex', 'Tenglan', 'Eric']
  10. >>> names[3:] #如果想取最后一个,必须不能写-1,只能这么写
  11. ['Rain', 'Tom', 'Amy']
  12. >>> names[3:-1] #这样-1就不会被包含了
  13. ['Rain', 'Tom']
  14. >>> names[0::2] #后面的2是代表,每隔一个元素,就取一个
  15. ['Alex', 'Eric', 'Tom']
  16. >>> names[::2] #和上句效果一样
  17. ['Alex', 'Eric', 'Tom']

追加

  1. >>> names
  2. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
  3. >>> names.append("我是新来的")
  4. >>> names
  5. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

插入

  1. >>> names
  2. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  3. >>> names.insert(2,"强行从Eric前面插入")
  4. >>> names
  5. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  6.  
  7. >>> names.insert(5,"从eric后面插入试试新姿势")
  8. >>> names
  9. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

修改

  1. >>> names
  2. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  3. >>> names[2] = "该换人了"
  4. >>> names
  5. ['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

删除

  1. >>> del names[2]
  2. >>> names
  3. ['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  4. >>> del names[4]
  5. >>> names
  6. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  7. >>>
  8. >>> names.remove("Eric") #删除指定元素
  9. >>> names
  10. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
  11. >>> names.pop() #删除列表最后一个值
  12. '我是新来的'
  13. >>> names
  14. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

扩展

  1. >>> names
  2. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
  3. >>> b = [1,2,3]
  4. >>> names.extend(b)
  5. >>> names
  6. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

拷贝

  1. >>> names
  2. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
  3.  
  4. >>> name_copy = names.copy()
  5. >>> name_copy
  6. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

统计

  1. >>> names
  2. ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
  3. >>> names.count("Amy")
  4. 2

排序&翻转

  1. >>> names
  2. ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
  3. >>> names.sort() #排序
  4. Traceback (most recent call last):
  5. File "<stdin>", line 1, in <module>
  6. TypeError: unorderable types: int() < str() #3.0里不同数据类型不能放在一起排序了,擦
  7. >>> names[-3] = ''
  8. >>> names[-2] = ''
  9. >>> names[-1] = ''
  10. >>> names
  11. ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '', '', '']
  12. >>> names.sort()
  13. >>> names
  14. ['', '', '', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']
  15.  
  16. >>> names.reverse() #反转
  17. >>> names
  18. ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']

获取下标

  1. >>> names
  2. ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']
  3. >>> names.index("Amy")
  4. 2 #只返回找到的第一个下标

元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表

语法

names = ("alex","jack","eric")

它只有2个方法,一个是count,一个是index,完毕。

2. 字符串操作 

  1. >>> n3_arg
  2. {'name': 'alex', 'age': 33}
  3. >>> n3
  4. 'my name is {name} and age is {age}'
  5. >>> n3.format_map(n3_arg)
  6. 'my name is alex and age is 33'
  7.  
  8. >>> n4.ljust(40,"-")
  9. 'Hello 2orld-----------------------------'
  10. >>> n4.rjust(40,"-")
  11. '-----------------------------Hello 2orld'
  12.  
  13. >>> s = "Hello World!"
  14. >>> p = str.maketrans("abcdefg","3!@#$%^")
  15. >>> s.translate(p)
  16. 'H$llo Worl#!
  17.  
  18. >>> b="ddefdsdff_哈哈"
  19. >>> b.isidentifier() #检测一段字符串可否被当作标志符,即是否符合变量命名规则
  20. True

3. 字典操作

字典一种key - value 的数据类型,使用就像我们上学用的字典,通过笔划、字母来查对应页的详细内容。

key-value对

  1. 特性:
  2. 无顺序
  3. 去重
  4. 查询速度快,比列表快多了
  5. 比list占用内存多

为什么会查询速度会快呢?因为他是hash类型的,那什么是hash呢?

哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值,这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的,所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

dict会把所有的key变成hash 表,然后将这个表进行排序,这样,你通过data[key]去查data字典中一个key的时候,python会先把这个key hash成一个数字,然后拿这个数字到hash表中看没有这个数字, 如果有,拿到这个key在hash表中的索引,拿到这个索引去与此key对应的value的内存地址那取值就可以了。

语法:

  1. info = {
  2. 'stu1101': "TengLan Wu",
  3. 'stu1102': "LongZe Luola",
  4. 'stu1103': "XiaoZe Maliya",
  5. }

字典的特性:

  • dict是无序的
  • key必须是唯一的,so 天生去重

增加

  1. >>> info["stu1104"] = "苍井空"
  2. >>> info
  3. {'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

修改

  1. >>> info['stu1101'] = "武藤兰"
  2. >>> info
  3. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

删除

  1. >>> info
  2. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
  3. >>> info.pop("stu1101") #标准删除姿势
  4. '武藤兰'
  5. >>> info
  6. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  7. >>> del info['stu1103'] #换个姿势删除
  8. >>> info
  9. {'stu1102': 'LongZe Luola'}
  10. >>>
  11. >>>
  12. >>>
  13. >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  14. >>> info
  15. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
  16. >>> info.popitem()
  17. ('stu1102', 'LongZe Luola')
  18. >>> info
  19. {'stu1103': 'XiaoZe Maliya'}

查找

  1. >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  2. >>>
  3. >>> "stu1102" in info #标准用法
  4. True
  5. >>> info.get("stu1102") #获取
  6. 'LongZe Luola'
  7. >>> info["stu1102"] #同上,但是看下面
  8. 'LongZe Luola'
  9. >>> info["stu1105"] #如果一个key不存在,就报错,get不会,不存在只返回None
  10. Traceback (most recent call last):
  11. File "<stdin>", line 1, in <module>
  12. KeyError: 'stu1105'

多级字典嵌套及操作

  1. av_catalog = {
  2. "欧美":{
  3. "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
  4. "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
  5. "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
  6. "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
  7. },
  8. "日韩":{
  9. "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
  10. },
  11. "大陆":{
  12. "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
  13. }
  14. }
  15.  
  16. av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
  17. print(av_catalog["大陆"][""])
  18. #ouput
  19. ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

其它姿势

  1. #values
  2. >>> info.values()
  3. dict_values(['LongZe Luola', 'XiaoZe Maliya'])
  4.  
  5. #keys
  6. >>> info.keys()
  7. dict_keys(['stu1102', 'stu1103'])
  8.  
  9. #setdefault
  10. >>> info.setdefault("stu1106","Alex")
  11. 'Alex'
  12. >>> info
  13. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  14. >>> info.setdefault("stu1102","龙泽萝拉")
  15. 'LongZe Luola'
  16. >>> info
  17. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  18.  
  19. #update
  20. >>> info
  21. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  22. >>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
  23. >>> info.update(b)
  24. >>> info
  25. {'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  26.  
  27. #items
  28. info.items()
  29. dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
  30.  
  31. #通过一个列表生成默认dict,有个没办法解释的坑,少用吧这个
  32. >>> dict.fromkeys([1,2,3],'testd')
  33. {1: 'testd', 2: 'testd', 3: 'testd'}

循环dict

  1. #方法1
  2. for key in info:
  3. print(key,info[key])
  4.  
  5. #方法2
  6. for k,v in info.items(): #会先把dict转成list,数据里大时莫用
  7. print(k,v)

程序练习

程序: 三级菜单

要求:

  1. 打印省、市、县三级菜单
  2. 可返回上一级
  3. 可随时退出程序
  1. menu = {
  2. '北京':{
  3. '海淀':{
  4. '五道口':{
  5. 'soho':{},
  6. '网易':{},
  7. 'google':{}
  8. },
  9. '中关村':{
  10. '爱奇艺':{},
  11. '汽车之家':{},
  12. 'youku':{},
  13. },
  14. '上地':{
  15. '百度':{},
  16. },
  17. },
  18. '昌平':{
  19. '沙河':{
  20. '老男孩':{},
  21. '北航':{},
  22. },
  23. '天通苑':{},
  24. '回龙观':{},
  25. },
  26. '朝阳':{},
  27. '东城':{},
  28. },
  29. '上海':{
  30. '闵行':{
  31. "人民广场":{
  32. '炸鸡店':{}
  33. }
  34. },
  35. '闸北':{
  36. '火车战':{
  37. '携程':{}
  38. }
  39. },
  40. '浦东':{},
  41. },
  42. '山东':{},
  43. }
  44.  
  45. exit_flag = False
  46. current_layer = menu
  47.  
  48. layers = [menu]
  49.  
  50. while not exit_flag:
  51. for k in current_layer:
  52. print(k)
  53. choice = input(">>:").strip()
  54. if choice == "b":
  55. current_layer = layers[-1]
  56. #print("change to laster", current_layer)
  57. layers.pop()
  58. elif choice not in current_layer:continue
  59. else:
  60. layers.append(current_layer)
  61. current_layer = current_layer[choice]

4.集合操作

集合是一个无序的,不重复的数据组合,它的主要作用如下:

  • 去重,把一个列表变成集合,就自动去重了
  • 关系测试,测试两组数据之前的交集、差集、并集等关系

常用操作

  1. s = set([3,5,9,10]) #创建一个数值集合
  2.  
  3. t = set("Hello") #创建一个唯一字符的集合
  4.  
  5. a = t | s # t 和 s的并集
  6.  
  7. b = t & s # t 和 s的交集
  8.  
  9. c = t s # 求差集(项在t中,但不在s中)
  10.  
  11. d = t ^ s # 对称差集(项在t或s中,但不会同时出现在二者中)
  12.  
  13. 基本操作:
  14.  
  15. t.add('x') # 添加一项
  16.  
  17. s.update([10,37,42]) # 在s中添加多项
  18.  
  19. 使用remove()可以删除一项:
  20.  
  21. t.remove('H')
  22.  
  23. len(s)
  24. set 的长度
  25.  
  26. x in s
  27. 测试 x 是否是 s 的成员
  28.  
  29. x not in s
  30. 测试 x 是否不是 s 的成员
  31.  
  32. s.issubset(t)
  33. s <= t
  34. 测试是否 s 中的每一个元素都在 t
  35.  
  36. s.issuperset(t)
  37. s >= t
  38. 测试是否 t 中的每一个元素都在 s
  39.  
  40. s.union(t)
  41. s | t
  42. 返回一个新的 set 包含 s t 中的每一个元素
  43.  
  44. s.intersection(t)
  45. s & t
  46. 返回一个新的 set 包含 s t 中的公共元素
  47.  
  48. s.difference(t)
  49. s - t
  50. 返回一个新的 set 包含 s 中有但是 t 中没有的元素
  51.  
  52. s.symmetric_difference(t)
  53. s ^ t
  54. 返回一个新的 set 包含 s t 中不重复的元素
  55.  
  56. s.copy()
  57. 返回 set s”的一个浅复制
  1. >>> a = {1,2,3,4}
  2. >>> b ={3,4,5,6}
  3. >>> a
  4. {1, 2, 3, 4}
  5. >>> type(a)
  6. <class 'set'>
  7. >>> a.symmetric_difference(b)
  8. {1, 2, 5, 6}
  9. >>> b.symmetric_difference(a)
  10. {1, 2, 5, 6}
  11. >>>
  12. >>>
  13. >>> a.difference(b)
  14. {1, 2}
  15. >>> a.union(b)
  16. {1, 2, 3, 4, 5, 6}
  17. >>> a.issu
  18. a.issubset( a.issuperset(
  19. >>> a.issubset(b)
  20. False

Python基础类型的更多相关文章

  1. python基础类型,字符串

    python基本类型小结 # str,可以用索引取值,但是不能通过索引改变值, # a = "123" a[0]=10,直接TypeError因为字符串是不可变类型 # list, ...

  2. python基础类型—列表

    列表 列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型比如: li = [‘alex’ ...

  3. python基础类型—字典

    字典 字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据.python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必 ...

  4. python基础类型—数字(Number)

    Python3 支持 int.float.bool.complex(复数). 在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long. 像大多数语言一样,数 ...

  5. python基础类型(字典:dict)

    字典的介绍: 字典(dict)Python中唯一的一个映射类型.他是以{}括起来的键值对组成,在dict中key是唯一的.在保存的时候,根据key来计算出一个内存地址,然后将key-value保存到这 ...

  6. 5、Python 基础类型 -- Dictionary 字典类型

    字典是另一种可变容器模型,且可存储任意类型对象. 字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 ,格式如下所示: d ...

  7. Python基础类型(1)

    整数 整数在Python中的关键字用int来表示; 整型在计算机中运于计算和比较 在32位机器上int的范围是:  -2**31-2**31-1,即-2147483648-2147483647 在64 ...

  8. python基础类型—集合

    一,集合. 集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的.以下是集合最重要的两点: 去重,把一个列表变成集合,就自动去重了. ...

  9. python基础类型—字符串

    字符串str 用引号引起开的就是字符串(单引号,双引号,多引号) 1.字符串的索引与切片. 索引即下标,就是字符串组成的元素从第一个开始,初始索引为0以此类推. a = 'ABCDEFGHIJK' p ...

随机推荐

  1. 跟我学android- 创建运行环境(二)

    Android程序 需要在Android手机上运行,因此 Android开发时 必须准备相关运行,调试环境. Android真机(建议使用真机,速度快,效果好) Android虚拟设备(AVD) 使用 ...

  2. 安装 vsftp

    1.yum安装 vsftp yum list vsftpd yum install vsftpd 2.配置 vsftp 将root注释掉 vi /etc/vsftpd/ftpusers 将root注释 ...

  3. C#的SerialPort串口程序设计总结

    简介:微软的VS提供了SerialPort控件,也就是串行端口资源. 当然也可以添加引用 using System.IO.Ports; 通过实例化SerialPort对象就可以使用其属性和方法了. S ...

  4. ajax+XMLHttpRequest里的FormData实现图片异步上传

    发这篇博客的时候我是自己在研究这个XMLHttpRequest请求,在别人的博客上面知道XMLHttpRequest新加了一个FormData的东西,好像现在APP请求后台也有用这种方式的吧. 别的不 ...

  5. laravel框架——上传、下载文件

    文件上传 在config文件夹下新建一个 项目名.php return [ 'title' => 'My Test', 'posts_per_page' => 5, 'uploads' = ...

  6. SQL Server T-SQL高级查询1

    高级查询在数据库中用得是最频繁的,也是应用最广泛的. Ø 基本常用查询 --select select * from student;   --all 查询所有 select all sex from ...

  7. 解决xp下无法通过windows installer服务安装此安装程序包。您必须安装带有更新版本Wi

    今天装 tortoisegit 的时候发现安装包不能使用.报错无法通过windows installer服务安装此安装程序包.您必须安装带有更新版本Windows Installer服务的Window ...

  8. Java中匿名类的两种实现方式(转)

    使用匿名内部类课使代码更加简洁.紧凑,模块化程度更高.内部类能够访问外部内的一切成员变量和方法,包括私有的,而实现接口或继承类做不到.然而这个不是我说的重点,我说的很简单,就是匿名内部类的两种实现方式 ...

  9. C51 延时程序

    一.相关换算 1.1s=10^3ms(毫秒)=10^6μs(微秒)=10^9ns(纳秒)=10^12ps(皮秒)=10^15fs(飞秒)=10^18as(阿秒)=10^21zm(仄秒)=10^24ym ...

  10. Python HiveServer2

    1. 安装pyhs2   pyhs2依赖项如下:   gcc-c++   python-devel.x86_64   cyrus-sasl-devel.x86_64   因此pyhs2的安装命令如下: ...