三小时快速入门Python第二篇--变量与集合

变量与集合

1、输入输出

# Python有一个打印语句
print ("I'm Python. Nice to meet you!") # => I'm Python. Nice to meet you!

# 获取控制台输入的简单方法
input_string_var = input("Enter some data: ") # 返回字符串类型的数据,从键盘输入的数据会以字符串的形式保存到 input_string_var
input_var = input("Enter some data: ") # 返回字符串类型的数据，从键盘输入的数据会以字符串的形式保存到 input_var
# 假设 input_var我们输入的是int类型的数据1234，那么我们需要进行类型转换
input_var # => "1234"
int(input_var) # => 1234

# 不需要先声明变量再使用
some_var = 5    # 通常使用小写字母与下划线命名变量
some_var  # => 5

# 访问一个未定义的变量会抛出一个异常
# 在“控制流”里会介绍更多异常处理
some_other_var  # 这里会抛出一个NameError

# if 可以用来写成类似C语言的 '?:' 条件表达式
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

2、列表 List

# List用来存储列表
li = []
# 可以有初始数据
other_li = [4, 5, 6]

# 添加元素到列表的尾
li.append(1) # [1]
li.append(2) # [1,2]
li.append(3) # [1,2,3]
li.append(4) # [1,2,3,4]
# 使用pop方法移除列表末尾的元素
li.pop()        # => 3 列表现在为 [1, 2, 4]
# 把3再放回去
li.append(3)    # li 现在为 [1, 2, 4, 3]

# 像数组一样访问一个list
li[0]  # => 1
# 通过下标重新定义一个元素的值
li[0] = 42
li[0]  # => 42
li[0] = 1  # 注意：设置回原始值
# 查看最后一个元素
li[-1]  # => 3

# 查找超过数据长度的值会抛出异常： IndexError
li[4]  # 抛出 IndexError

# 可以使用切片句法访问列表
# 这里类型数学上的开/闭区间 左闭右开 注意下标是从0开始
# 下标1-下标3[1,3)
li[1:3]  # => [2, 3]
# 下标2到末尾
li[2:]  # => [3, 4]
# 开头一直到下标3
li[:3]  # => [1, 2, 3]
# 开始到末尾步长为2
li[::2]   # =>[1, 3]
# 开始到末尾步长为-1
li[::-1]   # => [4, 3, 2, 1]
# 使用高级切片句法
# li[start:end:step]

# 使用切片进行深层拷贝
li2 = li[:]  # => li2 = [1, 2, 4, 3] 但 (li2 is li) 返回 false


# 使用“del”直接从列表中删除元素
del li[2] #liisnow[1,2,3]

# 可以直接添加一个列表
li + other_li #=>[1,2,3,4,5,6]
# 注: 变量li 和 other_li 值并没有变化

# 使用extend()方法，把列表串起来
li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]

# 删除第一个值与参数相同的元素
li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出异常 ValueError 列表中没有2

# 在指定下标插入元素
li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

# 获得第一个匹配的元素的下标
li.index(2)  # => 1
li.index(7)  # 抛出异常 ValueError 列表中没有7

# 使用“in”来检查列表中是否包含元素
1 in li #=>True
# 使用“len()”来检查列表的长度
len(li)   # => 6

3、元组 Tuple

# 元组(Tuple)与列表类似但不可修改
tup = (1, 2, 3)
tup[0]   # => 1
tup[0] = 3  # 抛出异常 TypeError

# 注意：如果一个元组里只有一个元素，则需要在元素之后加一个逗号；如果元组里没有元素，反而不用加逗号
type((1))   # => <class 'int'>
type((1,))  # => <class 'tuple'>
type(())    # => <class 'tuple'>

# 以下对列表的操作，也可以用在元组上
len(tup) # => 3
tup + (4,5,6) #=>(1,2,3,4,5,6)
tup[:2] #=>(1,2)
2 in tup #=>True

# 可以把元组的值分解到多个变量上
a,b,c= (1, 2, 3) #a is now 1,b  is now 2 and c is now 3
d,e,f= 4,5,6 # 也可以不带括号
# 如果不带括号，元组会默认带上
g = 4, 5, 6 #=>(4,5,6)
# 非常容易实现交换两个变量的值
e, d = d, e # d is now 5 and e is now 4

4、字典 Dictionaries

# 字典用来存储（键-值）映射关系 有点类似于其他语言里面的map
empty_dict = {}
# 这里有个带初始值的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 注意：字典 key 必须是不可以修改类型，以确保键值可以被哈希后进行快速检索
# 不可修改的类型包括：int, float, string, tuple
invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # 值可以是任意类型

# 使用[]查找一个元素
filled_dict["one"]   # => 1
# 使用"keys()"获得所有的“键”
filled_dict.keys()   # => ["three", "two", "one"]
# 注：字典的key是无序的，结果可以不匹配
# 使用"values()"获得所有的“值”
filled_dict.values()   # => [3, 2, 1]
# 注：同样，这是无序的

# 查询字条中是否存在某个”键“用 "in"
"one" in filled_dict   # => True
1 in filled_dict   # => False

# 查找一个不存在的key会抛出异常 KeyError
filled_dict["four"]   # KeyError

# 使用 "get()" 会避免抛出异常 KeyError
filled_dict.get("one") # => 1
filled_dict.get("four") # => None

# get方法支持默认参数，当key不存在时返回该默认参数
filled_dict.get("one", 4) #=>1
filled_dict.get("four", 4)   # => 4

# 注 filled_dict.get("four") 仍然返回 None
# (get不会把值插入字典中)
# 向字典中插入值的方式与list相同
filled_dict["four"] = 4  # now, filled_dict["four"] => 4

# "setdefault()" 只有首次插入时才会生效
filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

# 使用 del 从字典中删除一个键
del filled_dict["one"]  # Removes the key "one" from filled dict

# 从 Python 3.5 开始，可以使用**操作
{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

5、集合 Set

# Set与list类似，但不存储重复的元素
empty_set = set()
some_set = set([1, 2, 2, 3, 4])   # some_set is now  set([1, 2, 3, 4])

# 与字典类型一样，Set 里的元素也必须是不可修改的
invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

# Set也是无序的，尽管有时看上去像有序的
another_set = set([4, 3, 2, 2, 1])  # another_set is now set([1, 2, 3, 4])

# 从Python 2.7开始, {}可以用来声明一个Set
filled_set={1,2,2,3,4} #=>{1,2,3,4}
# Can set new variables to a set
filled_set = some_set
# 向Set中添加元素
filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
# 用 & 求 Set的交集
other_set = {3, 4, 5, 6}
filled_set & other_set # =>{3,4,5}
# 用 | 求 Set的合集
filled_set | other_set # =>{1,2,3,4,5,6}
# 用 - 前面的元素减去后面的元素
{1,2,3,4} - {2,3,5} # => {1,4}
# 用 ^ 求Set的差集 
{1,2,3,4}^{2,3,5} #=>{1,4,5}
# 检查右边是否是左边的子集
{1, 2} >= {1, 2, 3} # => False
# 检查左边是否是右边的子集
{1, 2} <= {1, 2, 3} # => True
# 检查元素是否在集合中
2 in filled_set   # => True
10 in filled_set   # => False

 上一篇：三小时快速入门Python第一篇--原始数据类型与操作

 下一篇：三小时快速入门Python第三篇--控制流分支与循环