您的位置:时时app平台注册网站 > 编程知识 > Python中元组列表与字典学习笔记【时时app平台注

Python中元组列表与字典学习笔记【时时app平台注

2019-11-08 01:36

split   这个函数的作用是将字符串根据某个分割符进行分割

          #利用extend()方法的特性,可以将一个列表中的元素完全复制给另外一个列表,下面创建了一个空列表d,然后将c列表中的元素复制给d
          >>> d=[]
          >>> d.extend(c)
          >>> print(d)
          [[1, 2, 3, 4, 5, 6, 7, 8, 9], ['www.qingsword.com']]

print (str) # 输出字符串 Runoob
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print (str[0]) # 输出字符串第一个字符 R
print (str[2:5]) # 输出从第三个开始到第五个的字符 noo
print (str[2:]) # 输出从第三个开始的后的所有字符 noob
print (str * 2) # 输出字符串两次 RunoobRunoob
print (str "TEST") # 连接字符串 RunoobTEST

['www', 'itdiffer', 'com']                   (这是用"."作为分割,得到了一个名字叫做列表(list)的返回值)

          #list.pop()方法接收一个索引值,如果不指定索引值则默认为最后一位元素的索引值,这个方法将取出对应元素,然后从列表中删除这个元素
          >>> print(a.pop())
          9
          >>> print(a)
          [3, 4, 5, 6, 7, 8]
          >>> print(a.pop(0))
          3
          >>> print(a)
          [4, 5, 6, 7, 8]

 

String.capitalize() #首字母大写

#首先来看python对字符串数据的分片提取方法,本例取出a指向的字符串数据中,索引位置为2的单个字符
          >>> a="abcdefg"
          >>> print(a[2])
          c

字符串截取用 变量[下标1,下标2]的形式,下标索引从0开始,末尾位置记为-1,是个左闭右开的区间,[ )。

'I like python'

          #python允许不同的键拥有相同的值,所以下面的语法是正确的
          b={"one":"qing","two":"qing"}

 

'www*itdiffer*com' 

python中,可以使用中括号创建列表,在上面的元组实例中的大部分操作都适用于列表,只需要将圆括号替换成中括号即可,不同点是,列表中仅包含一个元素时,不需要在末尾添加逗号,另外,列表可以添加或删除元素,请看下面的实例:

print (dict['one']) # 输出键为 'one' 的值        1 - 菜鸟教程
print (dict[2]) # 输出键为 2 的值             2 - 菜鸟工具
print (tinydict) # 输出完整的字典        {'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
print (tinydict.keys()) # 输出所有键     dict_keys(['name', 'site', 'code'])
print (tinydict.values()) # 输出所有值  dict_values(['runoob', 'www.runoob.com', 1])

>>> b.split(".")

          #另一种简便的获取元组中最后一个元素的方法,直接使用-1,以此类推,获取倒数第二个元素就使用-2作为索引值
          >>> print(a[-1])
          5
          >>> print(a[-2])
          4

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

String.upper() #String中的字母大写

#分号切片同样适用于字符串或元组列表,语法为"[起始索引:结束索引(不包含)]"

乘方是 a**b,不需要像c一样调用另外的函数库。

join拼接字符串

          #打印出a元组第一个元素,python的索引起始是从0开始的
          >>> print(a[0])
          1

完全可以理解。之前说了,什么时代了,还省啥内存啊,怎么方便怎么来。

占位符 说明
%s 字符串(采用str()的显示)
%r 字符串(采用repr()的显示)
%c 单个字符
%b 二进制整数
%d 十进制整数
%i 十进制整数
%o 八进制整数
%x 十六进制整数
%e 指数 (基底写为e)
%E 指数 (基底写为E)
%f 浮点数
%F 浮点数,与上相同
%g 指数(e)或浮点数 (根据显示长度)
%G 指数(E)或浮点数 (根据显示长度)

          #读取字典keys和values列表
          >>> print(a.keys())
          dict_keys(['早餐', '晚餐', '午餐'])
          >>> print(a.values())
          dict_values(['牛奶鸡蛋', '水果沙拉', '可乐牛排'])
0×4.数据分片实例

标准数据类型:

>>> c = b.split(".")

          #从b中索引为3(d)的位置开始,直到索引为5(f)的位置
          >>> b=["a","b","c","d","e","f","g"]
          >>> print(b[3:5])
          ['d', 'e']

集合,很好很强大。再见。

>>> s1

#创建三个列表,其中c为多维列表,包含a和b
          >>> a=[1,2,3,4,5]
          >>> b=["www.qingsword.com"]
          >>> c=[a,b]

用{}或者 set() 函数创建集合。 setA = {'hatemath'} 或者 setA = set('hatemath')

String.istitle() #String中字符串中所有的单词拼写首字母是否为大写,且其他字母为小写

文章目录

数字:

>>> ".".join(c)

          #程序输出
          {'E': 'Eva', 'G': 'George', 'Q': 'Qingsword', 'K': 'Kali', 'J': 'John', 'T': 'Tom'}
除了上面介绍的简单切片技术外,python还提供了一种特殊的切片技术,分号切片,请看下面的实例:

类似列表?行了,翻页。

'I like python'

#!/usr/bin/env python3
          #创建一个名称列表
          a=["Qingsword","John","Tom","George","Kali","Eva"]
          x=0
          #创建一个空字典
          b={}
          #当x值小于a列表元素个数时循环
          while x<len(a):
              b[a[x][0]]=a[x]
              x =1  
          print(b) 

列表的定义是 listA = [x, xx,xxx] ,方括号包起,逗号隔开,乍看起来像c语言里的数组,但其实不一样。从append()、pop()等方法来看,又像是java里面的数组。我姑且认为Python里面的列表是一种混合动力加强版的数组吧,可操纵性简直逆天。看例子:

['www', 'itdiffer', 'com']

          #使用set()能够删除列表中的重复值
          >>> e=["a","a","b","c","b"]
          >>> print(e)
          ['a', 'a', 'b', 'c', 'b']

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。

String.lstrip() 去掉字符串的左边空格

          #第二种方法创建字典,一次性添加所有的键值,用冒号分隔每一组元素,冒号前为"键",冒号后为"值""
          >>> a={'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

>>> b='www.itdiffer.com'

#创建三个元组,b元组仅包含一个字符串元素,所以末尾需要添加一个逗号,否则b将被创建为字符串对象,c元组是一个多维元组,包含了a和b元组
          >>> a=(1,2,3,4,5)
          >>> b=("www.qingsword.com",)
          >>> c=(a,b)

 

string.format()的格式化方法,其中{索引值}作为占位符,这个好变着花样的玩哦,这个不错,嘻嘻

          >>> e=set(e)
          >>> print(e)
          {'a', 'b', 'c'}
0×3.字典

 

>>> "I like %s" % "python"

在python中能够通过数据分片,实现读取某段字符串中单个字符的目的,这种思想同样适用于元组和列表,如果列表中储存的为字符串,就可以通过分片技术取出某个元素的第几个字符,这种方法在某些环境中会非常实用,请看下面的实例:

排好队,一个一个来。

>>> s1 = "I like {0}".format("python")

          #获取多维元组中,第0个元素(a元组)中索引位置为2的值,也就是a子元组中的3了
          >>> print(c[0][2])
          3
0×2.列表

元组写在小括号(())里,元素之间用逗号隔开,只有一个元素时,唯一的元素后面要加逗号。

String.isupper() #String中的字母是否全是大写

这篇文章介绍python中的三种组合数据类型,文章后半段会介绍如何在这些组合数据类型中使用"分片"取出数据。

另外,Python没有c语言的字符类型char。

关于类似的操作,还有很多变化,比如输出格式要宽度是多少等等,找了一个参考图,你看看开心就好

python中,使用大括号能够创建字典,字典中每个元素都是以"键值对"的形式储存的,请看下面的实例:

print(a | b)      # {'t', 'm', 'a', 'e', 'h'}
print(a - b)      # {'e'}
print(a & b)      # {'a', 't', 'h'}

 开始了,继续说!字符串替换,就是预留着空间,后边再定义要填上什么,这种叫字符串格式化,其有两种方法: %    和 format

          #提取b中索引位置为2的元素的最后一位字符
          >>> print(b[2][-1])
          8
使用字符串分片技术,将一组列表中的每个元素的首字母提取出来作为字典的键,并对应这个元素的值,下面是一段比较完整的程序:

 

String.islower() #String中的字母是否全是小写

0×1.元组

 

>>> a = "I LOVE PYTHON"

引言

str = 'Runoob'

String.strip() 去掉字符串的左右空格

          #打印出a元组中最后一个元素,len()函数将得到a元组元素的个数,因为索引是从0开始的,所以元素个数减一,就是最后一个元素的索引号
          >>> print(a[len(a)-1])
          5

示例速查:

>>> b = "www.itdiffer.com"

          #有两种方法可以读取字典中的值,直接使用"字典[键]"来读取值,或使用"字典.get(键)"来读取值
          >>> print(a["早餐"])
          牛奶鸡蛋
          >>> print(a.get("午餐"))
          可乐牛排

元组(Tuple)

>>> "*".join(c)

          #在列表数据中,可以将每个字符串元素看做一个子列表,使用多维列表的思想,提取子列表中对应索引位置的值
          >>> b=["www.qingsword.com","abcdefg","12345678"]
          >>> print(b[0][4])
          q

int就是长整型,没有c里面的短整型一说。看到了吧,随着计算机硬件的强大,过去无比宝贵的内存资源已经不稀罕了,怎么对程序员方便友好怎么来,这也是现代语言的一个基本设计思想。

'www.itdiffer.com'

          #从字符串a索引为2(3)的位置开始切片,直到索引6(7)的位置,截取这其中的数据输出(包含起始索引值,不包含结束索引值)
          >>> a="123456789"
          >>> print(a[2:6])
          3456

列表:

时时app平台注册网站 1

          #使用list.remove()方法可以删除列表中的元素,这个方法接收的不是索引值,而是元素值(本例直接删除了a列表中的元素1和2)
          >>> a.remove(1)
          >>> a.remove(2)
          >>> print(a)
          [3, 4, 5, 6, 7, 8, 9]

 

>>> c

在python中,元组使用中括号来创建,如果括号中仅包含一个元素,需要在元素末尾添加一个逗号(不添加逗号数据会被创建成字符串或数值数据类型),元组在创建后,不能添加删除其中的元素,其值是固定不变的,请看下面的实例:

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

String.rstrip() 去掉字符串的右边空格

          #分别打印出三个元组中的元素
          >>> print(a)
          (1, 2, 3, 4, 5)
          >>> print(b)
          ('www.qingsword.com',)
          >>> print(c)
          ((1, 2, 3, 4, 5), ('www.qingsword.com',))

本次学习主要是和数据类型混个脸熟,知道每样东西干什么的,有什么特点。具体用法和数据类型的方法,查工具书就行。

['I', 'LOVE', 'PYTHON']                  (这是用空格作为分割,得到了一个名字叫做列表(list)的返回值)

          #append()方法一次只能添加单个元素,而list.extend()方法一次可以添加多个元素
          >>> a.extend([7,8,9])
          >>> print(a)
          [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

列表

一些用逗号分隔而有序的数据,用方括号表示一个list,[ ] 在方括号里面,可以是int,也可以是str类型的数据,甚至也能够是True/False这种布尔值 ['2',3,'北京图灵','outman']

bool()是一个布尔函数,这个东西后面会详述。它的作用就是来判断一个对象是“真”还是“空”(假)

列表可以索引和切片,前面字符串我好像啰嗦过了,都是一样的

这里拓展下 双冒号使用,其实Python序列切片地址可以写为[开始:结束:步长],那么其中的开始和结束省略,就出现双冒号了

开始start省略时,默认从第0项开始。结尾省略的时候,默认到数组最后。步长step省略默认为1。当step等于负数的时候,从右向左取数

>>> alst = [1,2,3,4,5,6]

>>> alst[::-1]       #从右向左取数(反转过来了)

[6,5,4,3,2,1]

上面反转我们可以用reversed函数 

>>> list(reversed(alst))

[6,5,4,3,2,1]

好了下面我转用anaconda 里面的 jupyter打命令演示了(之前是在官方python3.7)没有 >>> 

``append()方法在列表的末尾添加一个元素   

s = [1,'a','3']
s.append('t')
print(s)

[1, 'a', '3', 't']

insert()任意位插入一个元素 (说到位置,你想到什么?没错,就是索引)

s = [1,'a','3']
s.insert(3,'t')       #在索引为3的位置加字符t,也就是字符串3后边
print(s)

[1, 'a', '3', 't']

使用del语句删除元素

motorcycles = ['honda', 'yamaha', 'suzuki']
del motorcycles[0]
print(motorcycles)
['yamaha', 'suzuki']

pop()弹出任意位置一个元素       (同样说位置,还是用索引,弹出?就是拿出来)

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.pop(1)       #括号内不填写默认为0,经常弹出的这个值我们会用到,这就是特殊的地方
print(motorcycles)
['honda', 'suzuki']

remove()不知道要从列表中删除的值所处的位置,只知道要删除的元素的值。(知道你要删除啊啥,这就够了)

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
motorcycles.remove('ducati')
print(motorcycles)
['honda', 'yamaha', 'suzuki']

好了,再说几个,不做命令演示了

list.clear()    从列表中删除所有元素。相当于 del a[:]

list.index(x)   返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误

list.count(x)    返回 x 在列表中出现的次数

list.sort()    对列表中的元素就地进行排序

list.reverse()    就地倒排列表中的元素

list.copy()    返回列表的一个浅拷贝。等同于 a[:]      说说这个吧,你可能会问啥是浅拷贝?演示代码给你看下,你会发现确实新拷贝的列表ID不一样,但里面元素ID一样

b = ['honda', 'yamaha', 'suzuki']
a = b.copy()
print(id(b))           #查看列表b的ID
print(id(b[1]))       #查看列表b中索引值为1的元素ID
print(a)
print(id(a))           #查看列表a的ID
print(id(a[1]))       #查看列表a中索引值为1的元素ID
99833224
99844368
['honda', 'yamaha', 'suzuki']
105157704
99844368

list.extend(b)      将一个给定列表中的所有元素都添加到另一个列表中,相当于 a[len(a):] = b 这个理解么?就是说列表a其切片从索引值"len(a)"到结束的部分就是列表b
a = [1, 2, 3]
b = ['qiwsir', 'python']
a.extend(b)
print(a)
[1, 2, 3, 'qiwsir', 'python']                    这里你想下和append()的区别

 

说到这,就不得不深入下,extend函数也是将另外的元素增加到一个已知列表中,其元素必须是iterable,什么是iterable?也就是可迭代

迭代是重复反馈过程的活动,其目的通常是为了接近并到达所需的目标或结果

hasattr()的判断本质就是看那个类型中是否有__iter__函数。可以用dir()找一找,在数字、字符串、列表、元组、集合、字典,谁有__iter__(截图了,打命令好累)

时时app平台注册网站 2为什么?数字你搞什么!

那我们想下,列表都干啥用呢?

1. 把列表当作堆栈使用

列表方法使得列表可以很方便的做为一个堆栈来使用,堆栈作为特定的数据结构,最先进入的元素最后一个被释放(后进先出)。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来

2. 把列表当作队列使用

可以把列表当做队列使用,队列作为特定的数据结构,最先进入的元素最先释放(先进先出)。不过,列表这样用效率不高。相对来说从列表末尾添加和弹出很快;在头部插入和弹出很慢(因为,为了一个元素,要移动整个列表中的所有元素)

3. 列表推导式(可嵌套)

列表推导式为从序列中创建列表提供了一个简单的方法。普通的应用程式通过将一些操作应用于序列的每个成员并通过返回的元素创建列表,或通过满足特定条件的元素创建子序列

 

          #打印出三个列表中的元素
          >>> print(a)
          [1, 2, 3, 4, 5]
          >>> print(b)
          ['www.qingsword.com']
          >>> print(c)
          [[1, 2, 3, 4, 5], ['www.qingsword.com']]

 

>>> a.split(" ")

#有两种方法可以创建字典,第一种直接创建一个空的字典,然后逐个添加键值
          >>> a={}
          >>> a["早餐"]="牛奶鸡蛋"
          >>> a["午餐"]="可乐牛排"
          >>> a["晚餐"]="水果沙拉"
          >>> print(a)
          {'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

 

String.lower() #String中的字母小写

          #使用list.append()方法,给a列表添加一个元素6
          >>> a.append(6)
          >>> print(a)
          [1, 2, 3, 4, 5, 6]

a = [9, 2, 13, 14, 15, 6]
a[2:5] = [] # 将对应的元素值设置为 []
print(a) # 结果是 [9, 2, 6]

%s  就是一个占位符,这个占位符可以被其它的字符串代替

和字符串不能改变其中的元素不同,列表里面的可以改,而且简直是随便改,不要太方便。

也有可能是因为我没把它当做谋生的手段。

字符串:

集合:

print (list) # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0]) # 输出列表第一个元素 abcd
print (list[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23]
print (list[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2]
print (tinylist * 2) # 输出两次列表 [123, 'runoob', 123, 'runoob']
print (list tinylist) # 连接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

数值运算符方面,大部分和c很像,少部分的不一样,确切的说,是更便利了。比如2/4的结果是0.5,Python会自动按浮点数计算。这样写在c里面就等于0了,要想得到0.5还得强制转换类型。那么,如果就是要取整怎么办,可以写成 2//4,结果是0。 //作为运算符,也决定了不能像c里面一样用它做单行注释。

既然提到了True和False,就说一下,Python3里,True和False是关键字,值分别是1和0。你可以试着print(True 1),结果是2。

 

 

 

 

按照老规矩, 表示转义,如果在字符串前加大写或者小写的R,就不再转义。

 

此物老夫从未见过。特地去搜索了一下,Tuple这个词似乎是Python特有的,不像list之类的词在生活中还有别的含义。只好认真看教程了。

共6种:Number(数字),String(字符串),List(列表),Tuple(元组),Sets(集合),Dictionary(字典)

 

用type()和isinstance()都可以得知某个变量所指向的对象的类型。区别是,type()比较死脑筋,但是isinstance()会认为子类是一种父类类型。即:isinstance(子类型) == 父类型 会返回True

 

肚子饿了。。。15年前初学编程的时候,经常去计算中心上机,为了debug经常错过饭点,而且把零钱用光了。下机后跑去跟老板赊账吃饭(此处应该有个笑哭的表情)。过了这么多年还是喜欢编程,看来是真爱。

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"

例子:

存放无序不重复元素的序列,用于进行成员关系测试和删除重复元素。

 

 

 

print(a ^ b)      # {'m', 'e'}
print( (a | b) - (a & b))      # {'e', 'm'} 果然就是我理解的意思。

教程里解释:

常见集合运算有:并集 |, 差集 - ,交集&, 不同时存在的元素集 ^ (按我理解就是并集减去交集)

a = set('hate')
b = set('math')

不能给字符串中的单个字符赋值, str[1]='a'会出错。

既然是熟人,就直接看例子吧。

 

 

比C简单的多,数字只有4种类型,分别是 int, float, bool, complex,纳尼?还有复数。

 

字符串用单引号(')或双引号(")括起来。我喜欢单引号,因为不用按shift,便捷高效。

字典是无序对象的集合,其中的元素时通过键(key)来存取的,取出来的叫值(value)。眼熟!java里面有这个玩意。我发现学这些高级特性的时候,跟c基本没啥关系了。。。。

 

重点:1)无序;2)不重复。

字典:

字符串连接用 号,复制字符串N次用*号。

本文由时时app平台注册网站发布于编程知识,转载请注明出处:Python中元组列表与字典学习笔记【时时app平台注

关键词:

  • 上一篇:没有了
  • 下一篇:没有了