Python入门(中)

最新推荐文章于 2023-08-18 14:53:15 发布
最新推荐文章于 2023-08-18 14:53:15 发布
阅读量901 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alisa_2018/article/details/108515000
版权

Python入门(中)

列表

简单数据类型

  • 整型<class 'int'>
  • 浮点型<class 'float'>
  • 布尔型<class 'bool'>

容器数据类型

  • 列表<class 'list'>
  • 元组<class 'tuple'>
  • 字典<class 'dict'>
  • 集合<class 'set'>
  • 字符串<class 'str'>

1. 列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，
语法为 [元素1, 元素2, ..., 元素n]。

  • 关键点是「中括号 []」和「逗号 ,」
  • 中括号 把所有元素绑在一起
  • 逗号 将每个元素一一分开

2. 列表的创建

  • 创建一个普通列表
x=['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x,type(x))

x=[2,3,4,5,6,7]
print(x,type(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
[2, 3, 4, 5, 6, 7] <class 'list'>

#利用Range()创建列表
x=list(range(10))
print(x,type(x))

x=list(range(1,11,2))
print(x,type(x))

x=list(range(10,1,-2))
print(x,type(x))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[10, 8, 6, 4, 2] <class 'list'>

#利用推导式创建列表
x=[0]*5
print(x,type(x))

x=[0 for i in range(5)]
print(x,type(x))

x=[i for i in range(10)]
print(x,type(x))

x=[i for i in range(1,10,2)]
print(x,type(x))

x=[i for i in range(10,1,-2)]
print(x,type(x))

x=[i ** 2 for i in range(1,10)]
print(x,type(x))

x=[i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x,type(x))

[0, 0, 0, 0, 0] <class 'list'>
[0, 0, 0, 0, 0] <class 'list'>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[10, 8, 6, 4, 2] <class 'list'>
[1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

x=[[0] * 3] * 4
print(x,type(x))

x[0][0]=1
print(x,type(x))

a=[0] * 3
x=a * 4
print(x,type(x))


[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] <class 'list'>

#创建一个混合列表
mix=[1,'lsgo',3.14,[1,2,3]]
print(mix,type(mix))

[1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>

#创建一个空列表
empty=[]
print(empty,type(empty))

[] <class 'list'>

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

  1. 向列表中添加元素

list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

x=['Monday','Tuesday','Wednesday','Thursday','Friday']
x.append('Thursday')
print(x)

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']

#此元素如果是一个list，那么这个list将作为一个整体进行追加，注意append()和extend()的区别
x=['Monday','Tuesday','Wednesday','Thursday','Friday']
x.append(['Thursday','Sunday'])
print(x)
print(len(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
6

#list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
x=['Monday','Tuesday','Wednesday','Thursday','Friday']
x.extend(['Thursday','Sunday'])
print(x)
print(len(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
7

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

list.insert(index, obj) 在编号 index 位置插入 obj。

x=['Monday','Tuesday','Wednesday','Thursday','Friday']
x.insert(2,'Sunday')
print(x)
print(len(x))

['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
6
  1. 删除列表中的元素

list.remove(obj) 移除列表中某个值的第一个匹配项

x=['Monday','Tuesday','Wednesday','Thursday','Friday']
x.remove('Monday')
print(x)

['Tuesday', 'Wednesday', 'Thursday', 'Friday']

# list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x=['Monday','Tuesday','Wednesday','Thursday','Friday']
y=x.pop()
print(y)

y=x.pop(0)
print(y)

y=x.pop(-2)
print(y)
print(x)

Friday
Monday
Wednesday
['Tuesday', 'Thursday']

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

del var1[, var2 ……] 删除单个或多个对象。

x=['Monday','Tuesday','Wednesday','Thursday','Friday']
del x[0:2]
print(x)

['Wednesday', 'Thursday', 'Friday']

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

  1. 获取列表中的元素

通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。

通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0],type(x[0]))
print(x[-1],type(x[-1]))
print(x[-2],type(x[-2]))

Monday <class 'str'>
['Thursday', 'Friday'] <class 'list'>
Wednesday <class 'str'>

切片的通用写法是 start : stop : step

#  情况 1 - "start :" 
#  以 step 为 1 (默认) 从编号 start 往列表尾部切片。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:])
print(x[-3:])

['Thursday', 'Friday']
['Wednesday', 'Thursday', 'Friday']

#  情况2 -":stop"
# 以 step 为 1 (默认)从列表头部往编号stop切片

y = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(y[:3])
print(y[:-3])

['Monday', 'Tuesday', 'Wednesday']
['Monday', 'Tuesday']

# -"start:stop"
#以 step 为 1(默认)从编号 start往编号stop切片
y = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(y[1:3])
print(y[-3:-1])

['Tuesday', 'Wednesday']
['Wednesday', 'Thursday']

# 情况4 - "start:stop:step"
#以具体的step从编号start往编号stop切片。注意最后把step设为-1，相当于反向排列
y = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(y[1:4:2])
print(y[:4:2])
print(y[1::2])
print(y[::2])

['Tuesday', 'Thursday']
['Monday', 'Wednesday']
['Tuesday', 'Thursday']
['Monday', 'Wednesday', 'Friday']

# 情况5 -":"
# 复杂列表中的所有元素(浅拷贝)
y = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(y[:])

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

# 浅拷贝与深拷贝
list1=[123,456,789,213]
list2=list1
list3=list1[:]

print(list2)
print(list3)
#list.sort(cmp=None, key=None, reverse=False) 
#  cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
#  key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
#  reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
list1.sort()   
print(list2)
print(list3)

list1=[[123,456],[789,213]]
list2=list1
list3=list1[:]
print(list2)
print(list3)
list1[0][0]=1
print(list2)
print(list3)

[123, 456, 789, 213]
[123, 456, 789, 213]
[123, 213, 456, 789]
[123, 456, 789, 213]
[[123, 456], [789, 213]]
[[123, 456], [789, 213]]
[[1, 456], [789, 213]]
[[1, 456], [789, 213]]
  1. 列表的常用操作符¶

等号操作符：==

连接操作符 +

重复操作符 *

成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

list1=[123,456]
list2=[456,123]
list3=[123,456]

print(list1 == list2)
print(list1 == list3)

list4=list1 + list2
print(list4)

list5= list3 * 3
print(list5)

print(123 in list3)
print(456 not in list3)

False
True
[123, 456, 456, 123]
[123, 456, 123, 456, 123, 456]
True
False

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

  1. 列表的其它方法
# list.count(obj) 统计某个元素在列表中出现的次数

list1=[123,456] * 3
print(list1)
num=list1.count(123)
print(num)

[123, 456, 123, 456, 123, 456]
3

#  list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

list1=[123,456] * 5
print(list1)
print(list1.index(123))
print(list1.index(123,1))
print(list1.index(123,3,7))

[123, 456, 123, 456, 123, 456, 123, 456, 123, 456]
0
2
4

#  list.reverse() 反向列表元素

x=[123,456,789]
x.reverse()
print(x)

[789, 456, 123]

list.sort(key=None, reverse=False) 对原列表进行排序。

key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

该方法没有返回值，但是会对列表的对象进行排序。

x=[123,456,789,213]
x.sort()
print(x)

x.sort(reverse=True)
print(x)

#获取列表的第二个元素
def takeSecond(e):
    return e[1]

x=[(2,2),(3,4),(4,1),(1,3)]
x.sort(key=takeSecond)   
print(x)

x.sort(key=lambda a:a[0])
print(x)

[123, 213, 456, 789]
[789, 456, 213, 123]
[(4, 1), (2, 2), (1, 3), (3, 4)]
[(1, 3), (2, 2), (3, 4), (4, 1)]

元组

「元组」定义语法为：(元素1, 元素2, …, 元素n)

小括号把所有元素绑在一起

逗号将每个元素一一分开

  1. 创建和访问一个元组

Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。

元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。

t1=(1,10.31,'python')
t2=1,10.31,'python'

print(t1,type(t1))
print(t2,type(t2))

tu1=(1,2,3,4,5,6,7)
print(tu1[1])
print(tu1[5:])
print(tu1[:5])

tu2=tu1[:]
print(tu2)

(1, 10.31, 'python') <class 'tuple'>
(1, 10.31, 'python') <class 'tuple'>
2
(6, 7)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5, 6, 7)

#  创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
#  元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

x=(1)
print(type(x))

x=2,3,4,5
print(type(x))

x=()
print(type(x))

x=(1,)
print(type(x))


print(8 * (8))
print(8 * (8,))

<class 'int'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
64
(8, 8, 8, 8, 8, 8, 8, 8)

#  创建二维元祖
x=(1,10.31,'python'),('data',11)
print(x)

print(x[0])
print(x[0][0],x[0][1],x[0][2])
print(x[0][0:2])

((1, 10.31, 'python'), ('data', 11))
(1, 10.31, 'python')
1 10.31 python
(1, 10.31)

#  2、更新和删除一个元祖
w = ('Monday','Tuesday','Tursday','Friday')
w = w[:2] + ('Wednesday',) + w[2:]
print(w)

('Monday', 'Tuesday', 'Wednesday', 'Tursday', 'Friday')

#  元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
t1=(1,2,3,[4,5,6])
print(t1)

t1[3][0] = 9
print(t1)

(1, 2, 3, [4, 5, 6])
(1, 2, 3, [9, 5, 6])
  1. 元组相关的操作符

等号操作符：==

连接操作符 +

重复操作符 *

成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

t1 = (123,456)
t2 = (456,123)
t3 = (123,456)

print(t1 == t2)
print(t1 == t3)

t4 = t1 + t2
print(t4)

t5 = t3 * 3
print(t5)

t3 *=3
print(t3)

print(123 in t3)
print(456 not in t3)

False
True
(123, 456, 456, 123)
(123, 456, 123, 456, 123, 456)
(123, 456, 123, 456, 123, 456)
True
False

#  4. 内置方法
#  元组大小和内容都不可更改，因此只有 count 和 index 两种方法。

t = (1,10.31,'python')
print(t.count('python'))  #count('python') 是记录在元组 t 中该元素出现几次，显然是 1 次
print(t.index(10.31))  #index(10.31) 是找到该元素在元组 t 的索引，显然是 1

1
1

#  5. 解压元组
#  解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t=(1,10.31,'python')
(a,b,c) = t
print(a,b,c)

1 10.31 python

#解压二维元组（按照元组里的元组结构来定义变量）

t=(1,10.31,('OK','python'))
(a,b,(c,d)) = t
print(a,b,c,d)

1 10.31 OK python

#  如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

t = 1,2,3,4,5
a,b, *rest,c=t
print(a,b,c)
print(rest)

1 2 5
[3, 4]

#  如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」

t = 1,2,3,4,5
a,b, *_=t
print(a,b)

1 2

字符串

  1. 字符串的定义

Python 中字符串被定义为引号之间的字符集合。

Python 支持使用成对的 单引号 或 双引号。

t1 = 'i love travel'
print(t1,type(t1))

t2 = "i love travel"
print(t2,type(t2))

print(5 + 8)
print('5' + '8')

i love travel <class 'str'>
i love travel <class 'str'>
13
58

Python 的常用转义字符

转义字符 描述

\ 反斜杠符号

’ 单引号

" 双引号

\n 换行

\t 横向制表符(TAB)

\r 回车

#  如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。

print('let \'s go')
print("let's go")
print('c:\\now')      
print("c:\\Program Files\\Intel\\WIFI\\Help")      

let 's go
let's go
c:\now
c:\Program Files\Intel\WIFI\Help

#  原始字符串只需要在字符串前边加一个英文字母 r 即可

print(r'c:\\Program Files\Intel\WIFI\Help')

c:\\Program Files\Intel\WIFI\Help

#  三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

p = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB(\t)。
也可以使用换行符[\n]
"""

print(p)

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB(	)。
也可以使用换行符[
]
  1. 字符串的切片与拼接

类似于元组具有不可修改性

从 0 开始 (和 Java 一样)

切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。

索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

s = 'I love travel'
print(s[:6])
print(s[5])
print(s[:6] + "插入的字符串" + s[6:])

s = 'travel'
print(s)
print(s[2:4])
print(s[-5:-2])
print(s[2])
print(s[-1])

I love
e
I love插入的字符串 travel
travel
av
rav
a
l

3、字符串的常用内置方法

#  capitalize() 将字符串的第一个字符转换为大写
#  lower() 转换字符串中所有大写字符为小写。
#  upper() 转换字符串中的小写字母为大写。
#  swapcase() 将字符串中大写转换为小写，小写转换为大写。

s = 'travel'
print(s.capitalize())
print(s.lower())
print(s.upper())
print(s.swapcase())

Travel
travel
TRAVEL
TRAVEL

#  count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数

s='travel'
print(s.count('a'))

1

#  endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
#  startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。

s="I love travel"
print(s.endswith('el'))
print(s.endswith('aa'))
print(s.startswith('i'))
print(s.startswith('I l'))

True
False
False
True

#  find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
#  rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。

s = 'I love travel'
print(s.find('love'))
print(s.rfind('tra'))

2
7

#  isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False

s = '12345'
print(s.isnumeric())
s += 'a'
print(s.isnumeric())

True
False

#  ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
#  rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

s='travel'
print(s.ljust(8,'0'))
print(s.rjust(8,'0'))

travel00
00travel

#  lstrip([chars]) 截掉字符串左边的空格或指定字符。
#  rstrip([chars]) 删除字符串末尾的空格或指定字符。
#  strip([chars]) 在字符串上执行lstrip()和rstrip()。

s = 'I love travel lsgoGroup'
print(s.lstrip())
print(s.lstrip().strip('I'))
print(s.rstrip())
print(s.strip())
print(s.strip().strip('p'))

I love travel lsgoGroup
 love travel lsgoGroup
I love travel lsgoGroup
I love travel lsgoGroup
I love travel lsgoGrou

#  partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。
#  rpartition(sub)类似于partition()方法，不过是从右边开始查找。

s = 'I love travel'
print(s.strip().partition('o'))
print(s.strip().partition('m'))
print(s.strip().rpartition('o'))

('I l', 'o', 've travel')
('I love travel', '', '')
('I l', 'o', 've travel')

#  replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次

s = 'I love travel'
print(s.strip().replace('I','We'))

We love travel

#  split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。

s = 'I love travel'
print(s.strip().split())
print(s.strip().split('o'))

u = 'www.baidu.com.cn'
print(u.split()) #使用默认分隔符
print(u.split('.'))
print(u.split(".",0))
print(u.split(".",2))
print(u.split(".",2)[1])

u1,u2,u3 = u.split(".",2)
print(u1)
print(u2)
print(u3)

['I', 'love', 'travel']
['I l', 've travel']
['www.baidu.com.cn']
['www', 'baidu', 'com', 'cn']
['www.baidu.com.cn']
['www', 'baidu', 'com.cn']
baidu
www
baidu
com.cn

#  去掉换行符

c = """[I 
love
travel]"""
print(c)
print(c.split('\n'))

print(c.split('[')[1].split(']')[0])
print(c.split('[')[1].split(']')[0].split())

[I 
love
travel]
['[I ', 'love', 'travel]']
I 
love
travel
['I', 'love', 'travel']

#  splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

s = 'I \n love \n travel'
print(s.splitlines())
print(s.splitlines(True))

['I ', ' love ', ' travel']
['I \n', ' love \n', ' travel']

#  maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
#  translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

s = 'I love travel'
it = 'aeiou'
ot = '12345'
tt = s.maketrans(it,ot)
print(tt)
print(s.translate(tt))

{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
I l4v2 tr1v2l

4、 字符串格式化

#  format 格式化函数

s = "{0} Love {1}".format('I','travel')
print(s)

s = "{a} love {b}".format(a='I',b='travel')
print(s)

s = "{0} love {b}".format('I',b='travel')
print(s)

s = '{0:.2f}{1}'.format(27.658,'GB')
print(s)

I Love travel
I love travel
I love travel
27.66GB

"""
Python 字符串格式化符号
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串，用str()方法处理对象
%r 格式化字符串，用rper()方法处理对象
%d 格式化整数
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g 根据值的大小决定使用%f或%e
%G 作用同%g，根据值的大小决定使用%f或%E

"""

'\nPython 字符串格式化符号\n符 号 描述\n%c 格式化字符及其ASCII码\n%s 格式化字符串，用str()方法处理对象\n%r 格式化字符串，用rper()方法处理对象\n%d 格式化整数\n%o 格式化无符号八进制数\n%x 格式化无符号十六进制数\n%X 格式化无符号十六进制数（大写）\n%f 格式化浮点数字，可指定小数点后的精度\n%e 用科学计数法格式化浮点数\n%E 作用同%e，用科学计数法格式化浮点数\n%g 根据值的大小决定使用%f或%e\n%G 作用同%g，根据值的大小决定使用%f或%E\n\n'

print('%c' %97)
print('%c %c %c' %(97,98,99))
print('%d + %d = %d' %(4,5,9))
print("我叫 %s 今年 %d 岁!" %('Alisa',18))
print('%o' % 10)
print('%x' % 10)
print('%X' % 10)
print('%f' % 27.658)
print('%e' % 27.658)
print('%E' % 27.658)
print('%g' % 27.658)
text="I am %d year old" %18
print("I said: %s." %text)
print("I said: %r." %text)

a
a b c
4 + 5 = 9
我叫 Alisa 今年 18 岁!
12
a
A
27.658000
2.765800e+01
2.765800E+01
27.658
I said: I am 18 year old.
I said: 'I am 18 year old'.

"""
格式化操作符辅助指令
符号 功能
m.n  m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
-    用作左对齐
+    在正数前面显示加号( + )
#    在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0    显示的数字前面填充'0'而不是默认的空格

"""

"\n格式化操作符辅助指令\n符号 功能\nm.n  m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）\n-    用作左对齐\n+    在正数前面显示加号( + )\n#    在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')\n0    显示的数字前面填充'0'而不是默认的空格\n\n"

print('%5.1f' %27.658)
print('%.2e' %27.658)
print('%10d' %10)
print('%-10d' %10)
print('%+10d' %10)
print('%#o' %10)
print('%#x' %108)
print('%010d' % 5)

 27.7
2.77e+01
        10
10        
       +10
0o12
0x6c
0000000005

字典

  1. 可变类型与不可变类型

序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。

字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。

那么如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法：

麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。

便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

#  整数 i 在加 1 之后的 id 和之前不一样，因此加完之后的这个 i (虽然名字没变)，但不是加之前的那个 i 了，因此整数是不可变类型。
#  列表 l 在附加 'Python' 之后的 id 和之前一样，因此列表是可变类型。

i = 1
print(id(i))
i = i + 2
print(id(i))

l = [1,2]
print(id(l))
l.append('travel')
print(id(l))

140711344092960
140711344093024
2164247476480
2164247476480

#  数值、字符和元组 都能被哈希，因此它们是不可变类型。
#  列表、集合、字典不能被哈希，因此它是可变类型。

print(hash('Name'))

print(hash(1,2,'travel'))

-9156271613887956812



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-27-e19ab279ef29> in <module>
      4 print(hash('Name'))
      5 
----> 6 print(hash(1,2,'travel'))


TypeError: hash() takes exactly one argument (3 given)
  1. 字典的定义

字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。

dict 内部存放的顺序和 key 放入的顺序是没有关系的。

dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。

字典 定义语法为 {元素1, 元素2, …, 元素n}

其中每一个元素是一个「键值对」-- 键:值 (key:value)

关键点是「大括号 {}」,「逗号 ,」和「冒号 :」

大括号 – 把所有元素绑在一起

逗号 – 将每个键值对分开

冒号 – 将键和值分开

#  3 创建和访问字典

brand = ['OLAY','SKII','FAB']
s = ['No fear of age!','Fairy water','save']
print('The slogan of SKII is:',s[brand.index('SKII')])

dic ={'OLAY':'No fear of age!','SKII':'Fairy water','FAB':'save'}
print('The slogan of OLAY is:',dic['OLAY'])

The slogan of SKII is: Fairy water
The slogan of OLAY is: No fear of age!

#  通过字符串或数值作为key来创建字典
#  注意：如果我们取的键在字典中不存在，会直接报错 keyError

d = {1:'云南',2:'Nepal',3:'杭州',4:'厦门',5:'武功山',6:'衡山',7:'阳朔','corn':67}
print(d)
print(d[1])
print(d[5])
print(d['corn'])
print(d[9])

{1: '云南', 2: 'Nepal', 3: '杭州', 4: '厦门', 5: '武功山', 6: '衡山', 7: '阳朔', 'corn': 67}
云南
武功山
67



---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-32-3760fab310b1> in <module>
      7 print(d[5])
      8 print(d['corn'])
----> 9 print(d[9])


KeyError: 9

#  通过元祖作为 key来创建字典，但一般不这样使用

d = {(1,2,3):"Alisa","Age":12,3:[3,5,7]}
print(d)
print(type(d))

{(1, 2, 3): 'Alisa', 'Age': 12, 3: [3, 5, 7]}
<class 'dict'>

#  通过构造函数 dict 来创建字典
#  dict() 创建一个空的字典

#通过 key 直接把数据放入字典中，但一个 key 只能对应一个 value，多次对一个 key 放入 value，后面的值会把前面的值冲掉。
d = dict()
d['a'] = 1
d['b'] = 2
d['c'] = 3
print(d)

d['a'] =11
print(d)

d['d'] = 4
print(d)

{'a': 1, 'b': 2, 'c': 3}
{'a': 11, 'b': 2, 'c': 3}
{'a': 11, 'b': 2, 'c': 3, 'd': 4}

#  dict(mapping) new dictionary initialized from a mapping object's (key,value) pairs

d = dict([('Alisa',2020),('Amy',2019),('bingo',2019)])
print(d)

d = dict((('Alisa',2020),('Amy',2019),('bingo',2019)))
print(d)

{'Alisa': 2020, 'Amy': 2019, 'bingo': 2019}
{'Alisa': 2020, 'Amy': 2019, 'bingo': 2019}

#dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

#这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
d = dict(name='Alisa',age=18)
print(d)
print(type(d))

{'name': 'Alisa', 'age': 18}
<class 'dict'>

4.字典的内置方法

#  dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

seq = ('name','age','sex')
d = dict.fromkeys(seq)
print(d)

d1 = dict.fromkeys(seq,10)
print(d1)

d2 = dict.fromkeys(seq,('Alisa','18','Female'))
print(d2)

{'name': None, 'age': None, 'sex': None}
{'name': 10, 'age': 10, 'sex': 10}
{'name': ('Alisa', '18', 'Female'), 'age': ('Alisa', '18', 'Female'), 'sex': ('Alisa', '18', 'Female')}

#  dict.keys() 返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
#  dict.values() 返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

d = {'Name':'Alisa','Age':18}
print(d.keys())
print(d.values())

lst = list(d.keys())
print(lst)
print(list(d.values()))

dict_keys(['Name', 'Age'])
dict_values(['Alisa', 18])
['Name', 'Age']
['Alisa', 18]

#  dict.items() 以列表返回可遍历的(键,值)元祖数组。

d = {'Name':'Alisa','Age':18}
print(d.items())

print(tuple(d.items()))
print(list(d.items()))

dict_items([('Name', 'Alisa'), ('Age', 18)])
(('Name', 'Alisa'), ('Age', 18))
[('Name', 'Alisa'), ('Age', 18)]

#  dict.get(key,default=None) 返回指定键的值，如果值不在字典中返回默认值
#  dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

d = {'Name':'Alisa','Age':18}
print("Age 值为： %s" % d.get('Age'))
print("Sex 值为： %s" % d.get('Sex',"NA"))

print("Age 值为： %s" % d.setdefault('Age',None))
print("Sex 值为： %s" % d.setdefault('Sex',None))

print(d)

Age 值为： 18
Sex 值为： NA
Age 值为： 18
Sex 值为： None
{'Name': 'Alisa', 'Age': 18, 'Sex': None}

#  key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。

d = {'Name':'Alisa','Age':18}

if 'Age' in d:
    print("键 Age 存在")
else:
    print("键 Age 不存在")

if 'Sex' not in d:
    print("键 Sex 不存在")
else:    
    print("键 Sex 存在")   

键 Age 存在
键 Sex 不存在

#  dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。
#  del dict[key] 删除字典给定键 key 所对应的值。

d = {1:"a",2:[1,2]}
print(d.pop(1),d)

print(d.pop(3,"nokey"),d) #设置默认值，必须添加，否则报错

del d[2]
print(d)

a {2: [1, 2]}
nokey {2: [1, 2]}
{}

#  dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。

d = {1:"a",2:[1,2]}
print(d.popitem())
print(d)

(2, [1, 2])
{1: 'a'}

#  dict.clear() 用于删除字段内所有元素

d = {'Name':'Alisa','Age':18}
print("字典长度： %d" % len(d))
d.clear()
print("字段删除后长度： %d" % len(d))

字典长度： 2
字段删除后长度： 0

#  dict.copy() 返回一个字典的浅复制
#  直接赋值和copy 的区别

d = {'Name':'Alisa','Age':18,'Class':[1,2,3]}
d1 = d        # 引用对象
d2 = d.copy() #浅拷贝父对象(一级目录),子对象(二级目录)不拷贝，还是引用

print(d1)
print(d2)
print(id(d))
print(id(d1))
print(id(d2))

#  修改 data数据
d['Name'] = 'root'
d['Class'].remove(1)

print(d)
print(d1)
print(d2)

{'Name': 'Alisa', 'Age': 18, 'Class': [1, 2, 3]}
{'Name': 'Alisa', 'Age': 18, 'Class': [1, 2, 3]}
3100498730560
3100498730560
3100498730624
{'Name': 'root', 'Age': 18, 'Class': [2, 3]}
{'Name': 'root', 'Age': 18, 'Class': [2, 3]}
{'Name': 'Alisa', 'Age': 18, 'Class': [2, 3]}

#  dict.update(dict2) 把字典参数 dict2 的 key:value 对 更新到字典 dict 里

d = {'Name':'Alisa','Age':18}
d1 = {'Sex':'Female','Age':20}
d.update(d1)
print(d)

{'Name': 'Alisa', 'Age': 20, 'Sex': 'Female'}

集合

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注意，key为不可变类型，即可哈希的值。

num = {}
print(type(num))
num = {1,2,3,4}
print(type(num))

<class 'dict'>
<class 'set'>

1.集合的创建

#  先创建对象再加入元素。
#  在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典

basket = set()
basket.add('apple')
print(basket)

{'apple'}

#  直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。
#  重复元素在set中会被自动被过滤。

basket = {'apple','orange','apple','pear','orange','banana'}
print(basket)

{'banana', 'apple', 'orange', 'pear'}

#  使用　set(value) 工厂函数，把列表或元祖转换成集合

a = set('abracadabra')
print(a)

b = set(("Google","Lsgogroup","Taobao","Taobao"))
print(b)

c = set(["Google","Lsgogroup","Taobao","Taobao"])
print(c)

{'a', 'r', 'c', 'd', 'b'}
{'Lsgogroup', 'Google', 'Taobao'}
{'Lsgogroup', 'Google', 'Taobao'}

#  去掉列表中重复的元素
#  从结果发现集合的两个特点：无序 (unordered) 和唯一 (unique)。
#  由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

lst = [0,1,2,3,4,5,5,3,1]

temp = []
for item in lst:
    if item not in temp:
        temp.append(item)

print(temp)        

a = set(lst)
print(list(a))

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

2.访问集合中的值

#  可以使用 len() 内建函数得到集合大小

s = set(['Google','Baidu','Taobao'])
print(len(s))

3

#  可以使用 for 把集合中的数据一个个读取出来

s = set(['Google','Baidu','Taobao'])
for item in s:
    print(item)

Taobao
Google
Baidu

#  可以通过 in 或 not in 判断一个元素是否在集合中已经存在

s = set(['Google','Baidu','Taobao'])
print('Taobao' in s)
print('Fackbook' not in s)

True
True

3.集合的内置方法

#  set.add(elmnt) 用于给集合添加元素，如果添加到元素在集合已经存在，则不执行任何操作。

fruits = {"apple","banana","cherry"}
fruits.add("orange")
print(fruits)

fruits.add("apple")
print(fruits)

{'banana', 'cherry', 'apple', 'orange'}
{'banana', 'cherry', 'apple', 'orange'}

#  set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

x = {"apple","banana","cherry"}
y = {"google","baidu","apple"}
x.update(y)
print(x)

y.update(["lsgo","dreamtech"])
print(y)

{'baidu', 'banana', 'apple', 'cherry', 'google'}
{'apple', 'dreamtech', 'baidu', 'google', 'lsgo'}

#  set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。
#  set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
#  set.pop() 用于随机移除一个元素。

fruits = {"apple","banana","cherry"}
fruits.remove("banana")
print(fruits)

fruits.pop()
print(fruits)

fruits.discard("banana")
fruits.remove("banana")
print(fruits)

{'cherry', 'apple'}
{'apple'}



---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-26-3a6c1e446b38> in <module>
     11 
     12 fruits.discard("banana")
---> 13 fruits.remove("banana")
     14 print(fruits)


KeyError: 'banana'

#  由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。
#  set.intersection(set1, set2) 返回两个集合的交集。
#  set1 & set2 返回两个集合的交集。
#  set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。
#  set.union(set1, set2) 返回两个集合的并集。
#  set1 | set2 返回两个集合的并集。
#  set.symmetric_difference(set)返回集合的异或。
#  set1 ^ set2 返回集合的异或。
#  set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)

c = a.intersection(b)
print(c)
print(a & b)
print(a)

print(a | b)

c = a.union(b)
print(c)

d = a.symmetric_difference(b)
print(d)
print(a ^ b)

print(a.symmetric_difference_update(b))

a.intersection_update(b)
print(a)

{'a', 'r', 'c', 'd', 'b'}
{'l', 'a', 'm', 'z', 'c'}
{'c', 'a'}
{'c', 'a'}
{'a', 'r', 'c', 'd', 'b'}
{'a', 'z', 'r', 'c', 'm', 'l', 'd', 'b'}
{'a', 'z', 'r', 'c', 'm', 'l', 'd', 'b'}
{'r', 'z', 'm', 'l', 'd', 'b'}
{'r', 'z', 'm', 'l', 'd', 'b'}
None
{'m', 'l', 'z'}

#  set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
#  set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
#  set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
#  set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
#  set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

x = {"a","b","c"}
y = {"f","e","d","c","b","a"}
z = x.issubset(y)
print(z)
print(x <= y)

x = {"a","b","c"}
y = {"f","e","d","c","b"}
z = x.issubset(y)
print(z)
print(x <= y)


y = {"a","b","c"}
x = {"f","e","d","c","b","a"}
z = x.issuperset(y)
print(z)
print(x >= y)

y = {"a","b","c"}
x = {"f","e","d","c","b"}
z = x.issuperset(y)
print(z)
print(x >= y)



y = {"a","b","c"}
x = {"f","e","d","c","b"}
z = x.isdisjoint(y)
print(z)

y = {"a","b","c"}
x = {"f","e","d","m","g"}
z = x.isdisjoint(y)
print(z)

True
True
False
False
True
True
False
False
False
True
  1. 集合的转换
se = set(range(4))
li = list(se)
tu = tuple(se)

print(se,type(se))
print(li,type(li))
print(tu,type(tu))

{0, 1, 2, 3} <class 'set'>
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>

5.不可变集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

#  frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10))
print(a)

b = frozenset('lsgogroup')
print(b)

frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
frozenset({'g', 'p', 'r', 's', 'o', 'u', 'l'})

序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

  1. 针对序列的内置函数
#  list(sub) 把一个可迭代对象转换为列表。
#  tuple(sub) 把一个可迭代对象转换为元祖
#  str(obj) 把obj对象转换为字符串


a = list()
print(a)

b = 'I love travel'
b = list(b)
print(b)

c = (1,1,2,3,5,8)
c = list(c)
print(c)


a = tuple()
print(a)

b = 'I love travel'
b = tuple(b)
print(b)

c = (1,1,2,3,5,8)
c = tuple(c)
print(c)


a = 123
a = str(a)
print(a,type(a))

[]
['I', ' ', 'l', 'o', 'v', 'e', ' ', 't', 'r', 'a', 'v', 'e', 'l']
[1, 1, 2, 3, 5, 8]
()
('I', ' ', 'l', 'o', 'v', 'e', ' ', 't', 'r', 'a', 'v', 'e', 'l')
(1, 1, 2, 3, 5, 8)
123 <class 'str'>

#  len(s) 返回对象（字符、列表、元组等）长度或元素个数。  s -- 对象。
#  max(sub)返回序列或者参数集合中的最大值
#  min(sub)返回序列或参数集合中的最小值
#  sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。

a = list()
print(len(a))

b = ('I','','l','o','v','e','','t','r','a','v','e','l')
print(len(b))

c = 'I love travel'
print(len(c))


print(max(1,2,3,4,5))
print(max([-8,99,7,83]))
print(max('Ilovetravel'))


print(min(1,2,3,4,5))
print(min([-8,99,7,83]))
print(min('Ilovetravel'))


print(sum([1,3,5,7,9]))
print(sum([1,3,5,7,9],10))

0
13
13
5
99
v
1
-8
I
25
35

"""
sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回重新排序的列表。

"""

x = [-8,99,3,7,83]
print(sorted(x))
print(sorted(x,reverse=True))

t = ({"Age":20,"Name":"Alisa"},{"Age":25,"Name":"Amy"},{"Age":10,"Name":"bingo"})
x = sorted(t,key=lambda a: a["Age"])
print(x)

[-8, 3, 7, 83, 99]
[99, 83, 7, 3, -8]
[{'Age': 10, 'Name': 'bingo'}, {'Age': 20, 'Name': 'Alisa'}, {'Age': 25, 'Name': 'Amy'}]

#  reversed(seq) 函数返回一个反转的迭代器。
#  seq -- 要转换的序列，可以是 tuple, string, list 或 range。

s = 'lsgogroup'
x = reversed(s)
print(x,type(x))
print(list(x))

t = ('l','s','g','o','g','r','o','u','p')
print(list(reversed(t)))

r = range(5,9)
print(list(reversed(r)))

x = [-8,99,3,7,83]
print(list(reversed(x)))

<reversed object at 0x000002D1E6720340> <class 'reversed'>
['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
[8, 7, 6, 5]
[83, 7, 3, 99, -8]

#  enumerate(sequence, [start=0])
#  用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

seasons =['Spring','Summer','Fall','Winter']
a = list(enumerate(seasons))
print(a)

b = list(enumerate(seasons,1))
print(b)

for i,element in a:
    print('{0},{1}'.format(i,element))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
0,Spring
1,Summer
2,Fall
3,Winter

"""
zip(iter1 [,iter2 [...]])
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
"""

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]

zipped = zip(a,b)
print(zipped)
print(list(zipped))

zipped = (a,c)
print(list(zipped))

a1,a2 = zip(*zip(a,b))
print(list(a1))
print(list(a2))

<zip object at 0x000002D1E40D3900>
[(1, 4), (2, 5), (3, 6)]
[[1, 2, 3], [4, 5, 6, 7, 8]]
[1, 2, 3]
[4, 5, 6]
Alisa_2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python基础入门（中）：数据结构大汇总--阿里云天池
qq_38156104的博客
09-09 878
列表 简单数据类型 整型<class 'int'> 浮点型<class 'float'> 布尔型<class 'bool'> 容器数据类型 列表<class 'list'> 元组<class 'tuple'> 字典<class 'dict'> 集合<class 'set'> 字符串<class 'str'> 1. 列表的定义 列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Pytho
C语言学生信息管理系统：学生信息增加、学生信息删除、学生信息修改、学生信息模糊查询、学生信息精确查询、使用.txt文件导入学生信息、使用.txt文件导出
qq_43413289的博客
11-04 1609
学生信息管理系统：hi记录， 学期期末的 C语言大作业了，一个学生信息管理系统，花费了将近一个星期的时间。学生信息管理系统，项目所需的需求：学生信息增加、学生信息删除、学生信息修改、学生信息模糊查询、学生信息精确查询、使用.txt文件导入学生信息、使用.txt文件导出学生信息功能。 不多说，上图： 以此记录，如果哪位仁兄想要交流学习。可以私我源码，有加必回复。微信： ...
短小视频网站sexcms源码 安装搭建环境加采集教程 有手机和PC演示站 linux下安装一片空白的解决linux下安装一片空白的解决
热门推荐
chenhao0568的专栏
04-25 11万+
电脑PC：http://video.supermindsoft.com/ 手机端：http://video.supermindsoft.com/wap/ 安装搭建环境教程 1，直接运行你的域名即可安装程序，安装时为了保证与演示站效果一样这里 数据库表前缀 请先不要修改  以后正式使用时再修改都可以，修改了就无法恢复我们提供的演示数据。。。 2，切记！！！安装完成后必须
韩国网站——访问量前100名
米灰色的天空～～
07-25 2万+
1. http://www.daum.net 2. http://www.naver.com3. http://www.nate.com4. http://www.bugs.co.kr5. http://www.sayclub.com6. http://www.netmarble.net7. http://www.buddybuddy.co.kr8. http://www.auction.co.k
Sex, crimes, and common sense: framing femininity from sensation to sexology【翻译】
hongfu951的专栏
03-05 1万+
ABSTRACT My dissertation tracks the production of "common sense" about female sexuality and psychology in nineteenth-century sensational British literature. I move from the sensation novel’s heyday, r...
Python入门
04-14
Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的，这本书适合入门人学习，希望这本书能带领...
python入门教程大全.pdf 精心整理
04-11
10.[python入门教程]python中关于单行注释、多行注释以及变量、类型基础知识用法 11.[python入门教程]Python3中关于字典和列表以及指定元素排序方法举例说明 12.[python入门教程]Python3中的type和object用法 13....
python入门奶牛问题
06-02
python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题...
python入门实例
09-16
Python入门实例，针对基本概念字典列表，字符串处理以及文件处理等实例
Python 入门
12-11
Python 入门学习文档，讲述Python基础知识，帮你快速学习
Python数据类型练习1
2301_76550501的博客
03-14 1374
Python数据类型练习
Python基础练习题--第四章 循环结构
sunshine8426的博客
04-12 8368
猜数方法是交互的：Bob输入猜测的数字，平台给出相应的提示：“偏大”“偏小”或“正确”。小明是一位精明的投资者。每年理财赎回后，他会提取2万元用作生活所需，余下的自己仍购买此种理财，在收益率不变的情况下，多少年后被自己全部取出？鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问鸡翁、鸡母、鸡雏各几何。若干行每行两个数，表示华氏温度（整数，占8个字符宽度）与摄氏温度（占10个字符宽度，保留两位小数）若干行每行两个数，表示华氏温度（整数，占8个字符宽度）与摄氏温度（占10个字符宽度，保留两位小数）
Python学习 —— 阶段综合练习一
weixin_30412013的博客
03-31 395
Python 阶段综合练习一 　　综合之前的函数、数据结构、流程控制等，做以下实例练习：（建议先不要看代码，自己先试着写；代码仅供参考，有多种实现方法） 　　1. 定义 is_Even 函数，传一 int 参数，判断是否是偶数，return True；不是，return False 1 '''is_Even''' 2 def is_Even(i): 3 if(i%2...
SEO地址收藏
江湖·郎中·路
09-06 2万+
http://whois.chinaz.com/v5v6s.com
Python常用数据结构-练习题
渴鱼y. . 。.
09-25 3173
目录 1、在屏幕上显示跑马灯文字 2、设计一个函数产生指定长度的验证码，验证码由大小写字母和数字构成 3、设计一个函数返回给定文件名的后缀名 4、设计一个函数返回传入的列表中最大和第二大的元素的值 5、计算指定的年月日是这一年的第几天 6、打印杨辉三角 7、双色球选号 8、约瑟夫环问题（需详细搞清楚） 9、井字棋游戏（未解决） 1、在屏幕上显示跑马灯文字 import os...
python3 0基础学习----数据结构（基础+练习）
08-18 1896
列表是一种有序的可变序列，可以包含不同类型的元素。列表可以通过方括号[]来表示，元素之间用逗号分隔。注释： 注意列表可变,字符串不可变,只能改变大小写元组是一种有序的不可变序列，同样可以包含不同类型的元素。元组可以通过圆括号()来表示，元素之间用逗号分隔。字典是一种键值对的集合，键和值可以是任意的数据类型。字典可以通过花括号{}来表示，每个键值对使用冒号 : 分隔，键值对之间用逗号分隔。可做内容修改a={age:10}print(a) #输出 {'age': 18}字典里边没有顺序 ,列表有从0开始。
2.Python数据结构与算法分析课后习题(第二版)__chapter2
conan04260426的博客
09-24 2722
Python数据结构与算法分析课后习题第二章答案
python数据结构题目_python学习5—一些关于基本数据结构的练习题
weixin_39654058的博客
11-24 105
1 #1. use _ to connect entries in a list2 #if there are no numbers in list3 li = ['alex','eric','rain']4 v = '_'.join(li)5 print(v)6 #if there are numbers in list7 li = ['alex','eric',123]8 nli = [] ...
数据分析1 -- 数据集的获取
weixin_49848200的博客
09-21 3547
数据分析之数据集的获取和构建简要说明
python 入门 pdf
最新发布
12-04
此外，一些 PDF 教程也会介绍如何在 Python 中进行数据分析、Web 开发、机器学习等应用。 对于初学者来说，选择一个适合自己水平的 Python 入门 PDF 教程非常重要。一些教程可能更适合那些没有编程经验的人，而另...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值