python学习六:数据结构

数据结构

列表

将列表当做堆栈使用

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

>>> stack = [345]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[34567]
>>> stack.pop()
7
>>> stack
[3456]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[34]

将列表当作队列使用

也可以把列表当做队列用,只是在队列里第一加入的元素,第一个取出来;但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快,然而在列表里插入或者从头部弹出速度却不快(因为所有其他的元素都得一个一个地移动)。

>>> from collections import deque
>>> queue = deque(["Eric""John""Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael''Terry''Graham'])

列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素,用其获得的结果作为生成新列表的元素,或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式,然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组,就必须使用括号。
这里我们将列表中每个数值乘三,获得一个新的列表:

>>> vec = [246]
>>> [3*x for x in vec]
[61218]
>>> [[x, x**2] for x in vec]
[[24], [416], [636]]
>>> freshfruit = ['  banana''  loganberry ''passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana''loganberry''passion fruit']

使用if作为过滤器:

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

以下是一些关于循环和其它技巧的演示:

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数:

>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1''3.14''3.142''3.1416''3.14159']

嵌套列表解析

Python的列表还可以嵌套。
以下实例展示了3X4的矩阵列表:

>>> matrix = [
...     [1234],
...     [5678],
...     [9101112],
... ]

以下实例将3X4的矩阵列表转换为4X3列表:

>>> [[row[i] for row in matrixfor i in range(4)]
[[1, 5, 9][2, 6, 10][3, 7, 11][4, 8, 12]]

也可以使用以下方法来实现:

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另一种实现方法:

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[159], [2610], [3711], [4812]]

del语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割,或清空整个列表(我们以前介绍的方法是给该切割赋一个空列表)。例如:

>>> a = [-1166.253333331234.5]
>>> del a[0]
>>> a
[166.253333331234.5]
>>> del a[2:4]
>>> a
[166.251234.5]
>>> del a[:]
>>> a
[]

也可以用 del 删除实体变量:

>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1in <module>
NameError: name 'a' is not defined

元组和序列

元组由若干逗号分隔的值组成,例如:

>>> t = 1234554321'hello!'
>>> t[0]
12345
>>> t
(1234554321'hello!')
>># Tuples may be nested:
... u = t, (12345)
>>> u
((1234554321'hello!'), (12345))

如你所见,元组在输出时总是有括号的,以便于正确表达嵌套结构。在输入时可能有或没有括号, 不过括号通常是必须的(如果元组是更大的表达式的一部分)。

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。注意:如果要创建一个空集合,你必须用 set() 而不是 {} ;后者创建一个空的字典,下一节我们会介绍这个数据结构。
以下是一个简单的演示:

>>> basket = {'apple''orange''apple''pear''orange''banana'}
>>> print(basket)                      # 删除重复的
{'orange''banana''pear''apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False

>>> # 以下演示了两个集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中唯一的字母
{'a''r''b''c''d'}
>>> a - b                              # 在 a 中的字母,但不在 b 中
{'r''d''b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a''c''r''d''b''m''z''l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a''c'}
>>> a ^ b                              # 在 a 或 b 中的字母,但不同时在 a 和 b 中
{'r''d''b''m''z''l'}

集合也支持推导式:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r''d'}

字典

另一个非常有用的 Python 内建数据类型是字典。
序列是以连续的整数为索引,与此不同的是,字典以关键字为索引,关键字可以是任意不可变类型,通常用字符串或数值。
理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内,关键字必须是互不相同。
一对大括号创建一个空的字典:{}。
这是一个字典运用的简单例子:

>>> tel = {'jack'4098'sape'4139}
>>> tel['guido'] = 4127
>>> tel
{'sape'4139'guido'4127'jack'4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido'4127'irv'4127'jack'4098}
>>> list(tel.keys())
['irv''guido''jack']
>>> sorted(tel.keys())
['guido''irv''jack']
>>'guido' in tel
True
>>'jack' not in tel
False

构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式,列表推导式指定特定的键值对:

>>> dict([('sape'4139), ('guido'4127), ('jack'4098)])
{'sape'4139'jack'4098'guido'4127}

如果关键字只是简单的字符串,使用关键字参数指定键值对有时候更方便:

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape'4139'jack'4098'guido'4127}

此外,字典推导可以用来创建任意键和值的表达式词典:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

遍历技巧

在字典中遍历时,关键字和对应的值可以使用 items() 方法同时解读出来:

>>> knights = {'gallahad''the pure''robin''the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时,索引位置和对应值可以使用 enumerate() 函数同时得到:

>>> for i, v in enumerate(['tic''tac''toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或更多的序列,可以使用 zip() 组合:

>>> questions = ['name''quest''favorite color']
>>> answers = ['lancelot''the holy grail''blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

要反向遍历一个序列,首先指定这个序列,然后调用 reversed() 函数:

>>> for i in reversed(range(1102)):
...     print(i)
...
9
7
5
3
1

要按顺序遍历一个序列,使用 sorted() 函数返回一个已排序的序列,并不修改原值:

>>> basket = ['apple''orange''apple''pear''orange''banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

关于sorted()的默认排序为顺序,参考:

>>> abc
{'a'11'b'12'c'13'e'15'd'14}
>>> abc.keys()
dict_keys(['a''b''c''e''d'])
>>> sorted(abc.keys())
['a''b''c''d''e']
>>> abc['ab']=110
>>> abc.keys()
dict_keys(['a''b''c''e''d''ab'])
>>> sorted(abc.keys())
['a''ab''b''c''d''e']
>>> abc['ba']=100
>>> sorted(abc.keys())
['a''ab''b''ba''c''d''e']

python学习五:函数

函数

函数

你可以定义一个由自己想要功能的函数,以下是简单的规则:

  • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def 函数名(参数列表):
    函数体

函数调用

定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。

参数传递

可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。

  • 不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。

python 函数的参数传递:

  • 不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
  • 可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响

python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。

参数

以下是调用函数时可使用的正式参数类型:

  • 必需参数:
    必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
  • 关键字参数:
    使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
  • 默认参数:
    调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值
  • 不定长参数
    需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。

#!/usr/bin/python3

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)

# 调用printinfo 函数
printinfo( 706050 )

输出结果如下:

输出: 
70
(60, 50)

如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例:

#!/usr/bin/python3

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return

# 调用printinfo 函数
printinfo( 10 )
printinfo( 706050 )

输出结果如下:

输出:
10
输出:
70
60
50

还有一种就是参数带两个星号 **,基本语法如下:

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)

输出结果如下:

输出: 
1
{'a': 2, 'b': 3}

声明函数时,参数中星号 * 可以单独出现,例如:

def f(a,b,*,c):
    return a+b+c

如果单独出现星号 * 后的参数必须用关键字传入。

>>def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3# 正常
6
>>>

匿名函数

python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式,函数体比 def 简单很多。
  • lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda 函数的语法只包含一个语句,如下:

lambda [arg1 [,arg2,.....argn]]:expression

实例:

#!/usr/bin/python3

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 1020 ))
print ("相加后的值为 : ", sum( 2020 ))

实例输出结果:

相加后的值为 :  30
相加后的值为 :  40

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。
以下实例修改全局变量 num:

#!/usr/bin/python3

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

输出结果如下:

1
123
123

如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:

#!/usr/bin/python3

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

输出结果如下:

100
100

python学习四:条件控制、循环语句、迭代器和生成器

条件控制、循环语句、迭代器和生成器

a,b=a,a+b 的计算方式为先计算右边表达式,然后同时赋值给左边,等价于:

n=b
m=a+b
a=n
b=m

关键字end可以用于将结果输出到同一行,或者在输出的末尾添加不同的字符,实例如下:

#!/usr/bin/python3

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

输出结果如下:

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

if语句

Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else

  1. 每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
  2. 使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
  3. 在Python中没有switch – case语句。

range()函数

内置range()函数,用于遍历数字序列,用法如下:

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>for i in range(5,9) :
    print(i)


5
6
7
8
>>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做’步长’),默认步长是1:

>>>for i in range(0103) :
    print(i)


0
3
6
9
>>>

负数:

>>>for i in range(-10, -100, -30) :
    print(i)


-10
-40
-70
>>>

结合range()和len()函数以遍历一个序列的索引,如下所示:

>>>a = ['Google''Baidu''Runoob''Taobao''QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

使用range()函数来创建一个列表:

>>>list(range(5))
[01234]

在 while(或for) … else 在条件语句为 false 时执行 else 的语句块:

#!/usr/bin/python3

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

输出结果:

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

pass语句

pass是空语句,是为了保持程序结构的完整性。pass 不做任何事情,一般用做占位语句,如下实例:

>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

最小的类

>>>class MyEmptyClass:
...     pass

以下实例在字母为 o 时 执行 pass 语句块:

#!/usr/bin/python3

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)

print ("Good bye!")

输出结果:

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

 迭代器

iter()和next()

>>>list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

使用for循环遍历

#!/usr/bin/python3

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

输出结果:

1 2 3 4

迭代器学习:

#! /usr/bin/python3

import sys

class MyNumbers:
  def __iter__(self):
    # self.a = 1
    return self

#   def __next__(self):
#     if self.a > 20:
#         print("跳出迭代")
#         raise StopIteration
#     else:
#         x = self.a
#         self.a += 1
#         return x

  def __next__(self):
    try:
        self.a+=1
        if self.a > 20:
            print("跳出迭代")
            raise StopIteration
        else:
            return self.a
    except StopIteration:
        print("捕获异常")
        sys.exit()

  def __init__(self):
    self.a=1
    print(self.a)

myclass = MyNumbers()
myiter = iter(myclass)
for i in myiter:
    print(i)

生成器

在 Python 中,使用了 yield 的函数被称为生成器(generator)。跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。

#!/usr/bin/python3

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 010
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10# f 是一个迭代器,由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

关于生成器的详细解释,参考链接:https://blog.csdn.net/mieleizhi0522/article/details/82142856

python学习三:列表、元组、字典、集合

列表、元组、字典、集合

列表

使用嵌套列表即在列表里创建其它列表,例如:

>>>a = ['a''b''c']
>>> n = [123]
>>> x = [a, n]
>>> x
[['a''b''c'], [123]]
>>> x[0]
['a''b''c']
>>> x[0][1]
'b'

相关函数:

函数 描述
list(seq) 将元组转换为列表
len(list) 列表元素个数
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort( key=None, reverse=False) 对原列表进行排序
list.clear() 清空列表
list.copy() 复制列表

元组

元组的元素不能修改。元组使用小括号,列表使用方括号

>>>tup1 = ('Google''Runoob'19972000);
>>> tup2 = (12345 );
>>> tup3 = "a""b""c""d";   # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>

tup1 = (); # 创建空元组

元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:

>>>tup1 = (50)
>>> type(tup1)     # 不加逗号,类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号,类型为元组
<class 'tuple'>

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:

#!/usr/bin/python3

tup = ('Google''Runoob'19972000)

print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)

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

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8in <module>
    print (tup)
NameError: name 'tup' is not defined

tuple(seq) 将列表转换为元组。区别于list(seq)是将元组转换为列表。如下实例:

>>> list1= ['Google''Taobao''Runoob''Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google''Taobao''Runoob''Baidu')

字典

不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:

#!/usr/bin/python3

dict = {'Name''Runoob''Age': 7, 'Name''小菜鸟'}

print ("dict['Name']: ", dict['Name'])

键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:

#!/usr/bin/python3

dict = {['Name']: 'Runoob''Age': 7}

print ("dict['Name']: ", dict['Name'])

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

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob''Age': 7}
TypeError: unhashable type'list'

str(dict) 输出字典,以可打印的字符串表示。

>>> dict = {'Name''Runoob''Age'7'Class''First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
函数 描述
radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
radiansdict.values() 返回一个迭代器,可以使用 list() 来转换为列表
pop(key[,default]) 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。

集合

集合的基本操作:

  1. 添加元素
    将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
    s.add( x )
>>>thisset = set(("Google""Runoob""Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao''Facebook''Google''Runoob'}

还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下:
s.update( x )
x 可以有多个,用逗号分开。

>>>thisset = set(("Google""Runoob""Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{13'Google''Taobao''Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{13456'Google''Taobao''Runoob'}
  1. 移除元素
    将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
    s.remove( x )
>>>thisset = set(("Google""Runoob""Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google''Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1in <module>
KeyError: 'Facebook'

此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
s.discard( x )

>>>thisset = set(("Google""Runoob""Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao''Google''Runoob'}

我们也可以设置随机删除集合中的一个元素,语法格式如下:
s.pop()

thisset = set(("Google""Runoob""Taobao""Facebook"))
x = thisset.pop()
print(x)
$ python3 test.py 
Runoob

多次执行测试结果都不一样。
然而在交互模式,pop 是删除集合的第一个元素(排序后的集合的第一个元素)。

>>>thisset = set(("Google""Runoob""Taobao""Facebook"))
>>> thisset.pop()
'Facebook'
>>> print(thisset)
{'Google''Taobao''Runoob'}
>>>

python学习二:运算符

运算符

算术运算符

运算符 描述 实例
** 幂 – 返回x的y次幂 a**b 为10的21次方
// 取整除 – 向下取接近除数的整数 >>> 9//2
4
>>> -9//2
-5

// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 

比较运算符

赋值运算符

运算符 描述 实例
**= 幂赋值运算符 c **= a 等效于 c = c**a
//= 取整除赋值运算符 c //= a 等效于 c = c//a

位运算符

运算符 描述 实例
& 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ,二进制解释: 0000 1100
| 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (a &#124; b) 输出结果 61 ,二进制解释: 0011 1101
^ 按位异或运算符:当两对应的二进位相异时,结果为1 (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
~ 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
<< 左移动运算符:运算数的各二进位全部左移若干位,由”<<“右边的数指定移动的位数,高位丢弃,低位补0。 a << 2 输出结果 240 ,二进制解释: 1111 0000
>> 右移动运算符:把”>>”左边的运算数的各二进位全部右移若干位,”>>”右边的数指定移动的位数 a >> 2 输出结果 15 ,二进制解释: 0000 1111

逻辑运算符

成员运算符

运算符 描述 实例
in 如果在指定的序列中找到值返回 True,否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True,否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。

注: id() 函数用于获取对象内存地址。

is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。

>>>a = [123]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

在交互模式中,最后被输出的表达式结果被赋值给变量 _ 。例如:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_2)
113.06

随机数函数

函数 描述
choice(seq) 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。
randrange ([start,] stop [,step]) 从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1
random() 随机生成下一个实数,它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数,它在[x,y]范围内。

格式化字符串输出

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python3

print ("我叫 %s 今年 %d 岁!" % ('小明'10))

输出结果:

我叫 小明 今年 10 岁!

python字符串格式化符号:

符号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

三引号

python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。实例如下:

#!/usr/bin/python3

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

实例输出结果:

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