python数据类型

Posted 2021-12-09 sunbinary

Date: 2019-05-27

Author: Sun

1. 自省机制

什么是自省？

自省（introspection）是一种自我检查行为。

自省是指这种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力

Python自省机制

? Python中比较常见的自省（introspection）机制(函数用法)有：help(), dir()，type(), hasattr(), isinstance()，通过这些函数，我们能够在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性。

dir()

　dir() 函数可能是 Python 自省机制中最著名的部分了。它返回传递给它的任何对象的属性名称经过排序的列表。如果不指定对象，则 dir() 返回当前作用域中的名称。让我们将 dir() 函数应用于 keyword 模块，并观察它揭示了什么：

>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

type()　

? type() 函数有助于我们确定对象是字符串还是整数，或是其它类型的对象。它通过返回类型对象来做到这一点，可以将这个类型对象与 types 模块中定义的类型相比较：

>>> type(100)
<class 'int'>
>>> type([])
<class 'list'>

hasattr()

? 对象拥有属性，并且 dir() 函数会返回这些属性的列表。但是，有时我们只想测试一个或多个属性是否存在。如果对象具有我们正在考虑的属性，那么通常希望只检索该属性。这个任务可以由 hasattr() 和 getattr() 函数来完成.

>>> dir(int)
>>> hasattr(int, '__doc__')
True

isinstance()

? 可以使用 isinstance() 函数测试对象，以确定它是否是某个特定类型或定制类的实例：

>>> isinstance("python", str)
True

2 变量

计算机本质上是一种可以执行计算的机器，这里的计算是一种广义的“计算”，计算机上所有的处理都可以看做是计算。要计算必须的有数据，在程序中如何表示数据呢？

扩展知识：

? 运行中的程序变量保存在内存中，当执行过程中需要计算的部分放入CPU

? 访问速度：CPU > 内存 > 磁盘

在程序中，我们一般以变量表示数据，所谓变量：

• 变量是用来保存数据的
• 在程序中，变量的值是可以改变的，所以叫变量，不能改变的叫常量

2.1 变量定义

变量定义： 
    变量名 = 值（对象）

name = '杨幂'    #通过type就可以判断数据类型
age = 20
student = Student()   #类的实例化对象

2.2 变量命名规范

变量名也可称之为标识符（变量名、函数名、类名、报名等统称为标识符），其命名要符合python的语法要求：

• 由数字、字母、下划线组成，不能以数字开头

• 严格区分大小写

• 不能是python的关键字（保留字）

  获取python的保留字
  import keyword
  print(keyword.kwlist)
  ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
  

2.3 变量命名风格

好的变量命名风格应该见名知意，有意义。

• 见名知意，有自描述性
• 不建议使用中文命名变量
• 一般变量可以用小驼峰规则：变量名由多个单词组成，第一个单词首字母小写，其它单词首字母大写
• 也可以全部变量名都小写，单词之间用下划线分隔

小驼峰命名：
    myBook   yourMoney
 下划线分隔：
    my_book    your_money

模块名：
小写字母，单词之间用_分割
eg： my_test.py

包名：
和模块名一样

?

类名：
单词首字母大写，采用驼峰式命名规范。
Student
PersonList

函数&方法

函数名应该为小写，可以用下划线风格单词以增加可读性。如：myfunction，my_example_function。

函数和方法的参数
总使用“self”作为实例方法的第一个参数。总使用“cls”作为类方法的第一个参数。

全局变量名（类变量，在java中相当于static变量）：
大写字母，单词之间用_分割
SNUMBER
COLOR_WRITE

普通变量：
小写字母，单词之间用_分割
this_is_a_var

实例变量：

? 大多数情况在类中， 以_开头，其他和普通变量一样

 _price    
 _instance_var 

私有实例变量（外部访问会报错）：
以 _ _ 开头（2个下划线），其他和普通变量一样

 __private_var 

专有变量：
_ _ 开头， _ _结尾，一般为python的自有变量，不要以这种方式命名

__doc__
__class__

普通函数：
和普通变量一样：

get_name() 
count_number() 
ad_stat() 

私有函数（外部访问会报错）：

? 以__开头（2个下划线），其他和普通函数一样

__get_name() 

2.4 变量输入和输出

• 变量输出

  print函数 
      作用：将数据显示到屏幕
  用法：
      显示字符串
      print('hello')
  
      显示变量
      age = 20
      print(age)
  
      显示多个字符串和变量
      age = 20
      sex = '男'
      print('俺是大傻',age,sex)
  
      格式化显示
      name = '大傻'
      age = 20
      #%s和%d叫占位符，替变量站了位置，显示的时候会用变量的值替换占位符
      #占位符和和后面小括号里的变量一一对应
      print('俺是%s,俺今年%d岁了'%(name,age))
  
      常见的占位符
      %s  字符串占位符
      %d  整数的占位符
      %f  浮点数的占位符
  

• 变量输入

  input用于输入数据给变量
  #input括号中字符串用于提示用户，不用输入
  age = input('请输入你的年龄')
  print(age)
  

2.5 变量删除

删除后变量就不存在了，不能够在通过变量名进行存取了
del 变量名              #将变量名从内存中删除掉

2.6 变量和内存

? python中一切都是对象，python中变量保存了对象的引用，变量的好比是一个容器，容器中保存的变量所指对象的引用（地址）；变量本身是没有类型的，变量的类型是指其所指对象的类型，比如说变量是一个瓶子，盛了醋就是醋瓶，盛了酱油就是酱油瓶

• python中变量的所指对象的地址可以用id函数获取
• 获取变量的类型可以使用type函数

num1 = 10
print(id(num1))    # 查看变量所指对象的地址
print(type(num1))  # 查看变量的类型

2.7 注意事项

• 变量必须先定义后使用

• =两边要留一个空格

3 常量

程序在运行的过程中，值永远不会发生改变的量称之为常量

python没有专门的常量类型，一般约定俗成使用大写表示常量

import math
math.pi

# 圆周率
PI = 3.1415926


# 我的生日
MY_BIRTHDAY = '2008/2/29'

4 注释

python解释器不解释、不执行注释

• 注释的优点：

  • 注释可以提高代码的可读性、可维护性。
  • 保留代码
  • 方便调试

• 注释的书写格式

  • 单行注释，以#开始，一直到本行结束都是注释

    #这是单行注释
    
    age = 20  #这也是单行注释
    

  • 多行注释

    #1.使用三个单引号
    '''
    中间的任何内容都是注释，
    可以有多行
    但中间不能再有三个单引号
    
    '''
    
    #2.使用三个双引号
    """
    中间都是注释内容
    但不能出现三个双引号
    """
    

• 注意

  • 单行注释一般出现在注释代码的上面和右面
  • 良好的注释是一个优秀程序员的基本素质
  • 不要每行代码都加注释，只注释比较难懂的代码，或对变量说明

5. 变量作用域

按照作用域划分，可以分为：

• L：Local，局部作用域
  
• E：Enclosing，闭包作用域【闭包外的函数中定义的变量】
• G：Global，全局作用域 在所有函数外定义的变量
• B：Built-in，內建作用域【内置作用域】

#1 局部作用域  
#局部变量只能在函数内部使用，外部无法引用
#局部变量的作用域从定义开始到函数体结束
def demo():
    num = 20  #局部变量  
    print(num)
demo()
#print(num) 错误

#函数作用域
#
def outter():
   x = 10   #函数作用域,从定义开始到本函数结束
   def inner():
      y = x  #在闭包中可以引用
      print(y)
   return inner
pf = outter()
pf()  #执行闭包
print(pf.__closure__)

#全局作用域
x = 100    #全局作用域  从定义开始到本文件结束
def demo():
   print(x)
print(x)

#内建作用域，是指系统内建的函数或常量，在系统载入时加载，在所有模块中都可以直接引用
#比如说系统函数
print(max(1,2,3))  #max函数就是内建作用域  哪里都可以引用
def  demo():
    x = 30
    y = 50
    print(max(x, y))

5.1 变量作用域查找规则

以 L --> E --> G -->B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，最后到内建作用域中找。

5.2 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，被称为局部变量

定义在函数外面的变量拥有一个全局作用域，被称为全局变量

total = 0   #全局变量

def sum(arg1,arg2):

    total = arg1 + arg2   #局部变量
    print("函数内部：",total)

    return total

sum(10,20)
#print(total1)
print("函数外部：",total)


num = 1
def fun1():
    print(num) #UnboundLocalError: local variable 'num' referenced before assignment
    num = 123
    print(num)

fun1()

6 数据类型

不同类型的变量可以进行的运算是不同的，所以必须理解变量的类型，python中数据类型可以分为：

• 内置类型

  内置类型分两个部分：基础类型（Number，String，Boolean，None）和 容器类型

  • Number：数值类型【整型，浮点型，复数 3+5j】
  • String:字符串
  • Boolean:布尔值【True，False】
  • None：空值，表示变量没有确定的值
  • list：列表
  • tuple：元组
  • dict：字典
  • set：集合

• 自定义类型

  • class ：类

6.1 基础类型

基础类型

? 包含Number，String，Boolean， None

• 整型（int）： python3中只有int一种，可以表示整数，例如：10，-5,10000

  python的int型也是4个字节，就是最大值也只是2^31；但是python 自带大数整数运算，整数不会溢出，只要内存足够

• 浮点型（float）： 表示带小数点的实数，有两种表示法：

  • 小数表示： 1.9 .23

  • 科学计数法： 用e来表示10的指数，1e2就代表了100，注意e前面必须有数值，e后面必须为整数

    print(float("%.3f" % 12.45623))   #保留小数点后三位浮点数
    

• 复数（complex）：表示数学上的无理数，形如：a+bj

  aComplex = 1.56 + 1.2j
  bComplex = 1 - 1j
  print(aComplex.real, aComplex.imag）    #显示aComplex的实部和虚部
  aComplex - bComplex    #运算
  abs(aComplex) #返回复数的模长
  

• 布尔型(bool)：表示事务的两种状态，男女、阴晴、亮暗等，它只有两个值：True，False

  1 print(True==1)                        # 返回True
  2 print(False==0)                       # 返回True
  3 print(1 is True)                    
  4 print(0 is False)
  

• None：表示空对象，一般用于判断，不同于0和空字符

  Null表示对象或某种数据类型（数据类型也为空，python中万物皆为对象）为空，而None表示一种一种特殊的数据类型

  >>> s = ''     #为s赋值一个空字符串
  >>> print(s)   #该行打印了一个空字符串
  >>> s == None  #可见,None不等于空
  False
  

• 字符串（str）：在python中，可以使用字符串表示文本

  • 字符串的表示

    # 用单引号表示： 'hello'
    # 用双引号表示："我用python"
    # 用3个单引号表示：可以表示多行文本，例如：
        '''伟大
           的
           祖国
         '''
    # 用3个双引号表示：可以表示多行文本，例如：
        """生死看淡，
        不服就干"""
    

  • 转义字符：有些特殊字符无法从键盘输入，可以使用转移字符表示，另外，无论是单引号、双引号还是双引号字符串，在单引号字符串中如何表示一个单引号呢，这也可以使用转义字符表示。常见的转义字符

    转义字符	描述	转义字符	描述
    ‘	表示一个普通字符单引号	\r	回车
    "	表示一个普通字符双引号	\r	回车
    ‘‘‘	一个普通的三单引号	\\	一个普通的字符\
    """	一个普通的三双引号	\a	响铃
    \t	tab键	\b	回删一个字符

    a = ‘My name‘s sunnychou‘

    print(a)

  ? 输出：

  ? My name‘s sunnychou

  ? c = "My name is Peter.\tYour name is Alice."

  ? print(c)

  ? 输出：

  ? My name is Peter. Your name is Alice.

  ? 如果将上述的\t换成\n 呢？

  ? 如果不希望字符串转义呢？

  ? 在字符串前加上r或者R

  ? c = "My name is Peter.\tYour name is Alice."

  ? print(c)

  ? 输出：

  ? My name is Peter. \tYour name is Alice.

  • 字符串编码：计算机只能识别二进制，那么字符串如何存储到计算机里呢

    计算机不能直接存储字符串，但我们可以将字符编码，例如用65表示大写字符A，66表示大写字符B....等这种表示方式就是美国类的ASCII码，只能表示127个字符，但对于美国人来说已经足够了。一但能用整数表示字符，我们可以很方便的把整数用二进制表示，那么字符串也就和容易存储到计算机了。
    但还有很多其他国家的语言是不能用ASCII表示的，所有ISO组织就推出了unicode码，用来表示任何一种语言的字符，unicode码也称之为万国码，通用码，可以表示任何一种语言的任何一个字符。unicdoe码有多中表示方式，例如：utf-8、utf-16、utf-32等。一般使用较多的是utf-8，utf-8是一种变长的编码，表示一个字符可能用一个字节，也可能是三个字节
    中文常用编码一般用GBK编码，用2个字节表示一个汉字
    

chr()函数

? 是将编码转换成对应的字符

print(chr(65))
print(chr(97))

6.2 容器类型

容器类型有：

? list：列表， tuple：元组， dict：字典， set：集合

List（列表）

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不一定需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = list([1, 3, 4, 5])
list3 = ["a", "b", "c", "d"]

—— 双向链表 有序，可变, 操作: 插入(append，insert， extend 任何位置)， 删除（remove， pop，任何位置）， 查找（L[index], 任何位置）， 遍历（列表，下标索引）

1 —》 2 —》 3 —》 4

《— 《— 《---

1、追加：names.append()

>> > names.append('e')
>> > names
['a', 'b', 'c', 'd', 'e']

2、删除：pop，remove，del

? 1）pop()

>> > names.pop()
'e'

? 如果没有指定下标，则默认会删除最后一个元素，如上述例子

>>> names.pop(2)
'c'

? 指定下标时，就会删除下标所对应的元素

? 2）remove()

>>> names.remove('e')
>>> names
['a', 'b', 'c', 'd']

? 3）del

>>> del names[4]
>>> names
['a', 'b', 'c', 'd']

?

3、查找元素所在位置：index()

>>> names.index('c')
2

4、统计元素的次数：count()

>>> names.append('d')
>>> names.count('d')
2

5、反转：reverse()

>>> names.reverse()
>>> names
['d', 'c', 'b', 'a']

6、清空：clear()

>>> names.clear()
>>> names
[]

7、插入：insert()

>>> names.insert(2,'devilf')
>>> names
['a', 'b', 'devilf', 'c', 'd']

#还有其他的插入方法：
>>> names[3] = 'lebron'

8、排序：sort()按照ascii码来进行排序

>>> names.insert(4,'&&')
>>> names
['a', 'b', 'd', 'devilf', '&&', 'lebron']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron']

9、拼接两个列表：extend()

>>> names.extend(place)
>>> names
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

10、对列表进行切片处理

1）列出所有的元素

>>> names[::]
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

2）列出最后一个元素，从中间位置开始，列出后面所有的元素

>>> names[-1]
'usa'

案例：列表操作

#1.列表组合  将多个列表拼接为一个列表
#直接使用加号
list1 = [43,65,76,6]
list2 = [45,77,90,11,2,4,66]
print(list1 + list2)  #产生一个新列表

#2.列表重复
#直接使用乘号 列表元素重复指定遍数，产生一个新列表
print(list1 * 4)

#3.成员操作
#成员运算符：in      not in
#运算的结果为布尔值
list3 = ["hello",False,189,"good"]
print(189 in list3) #True
print(180 not in list3)  #True

#4.列表的截取【分片，切片】
#语法：列表名[开始下标:结束下标：步长]，表示按指定步长获取从开始下标到结束下标之间的元素，
#     结果为一个新的列表，步长默认是1
#注意：包头不包尾【前闭后开区间】   [开始下标,结束下标)
#步长：默认是1，正数表示从左向右取，负数表示从右向左取
list1 = [10,20,30,40,50,60]
print(list1[0:3])   #[10,20,30]
print(list1[:3])    #[10,20,30]
print(list1[:])     #[10,20,30,40,50,60] 从头取到尾
print(list1[::2])     # [10,30,50] 隔一个取一个
print(list1[3:0:-1])  #[40, 30, 20, 10]  从右向左取
print(list1[-1:-3:-1]) #[60, 50] 从右向左取
print(list1[2:]) #[30, 40, 50, 60] 从下标为2的元素开始取到末尾
print(list1[-3::-1])#[40, 30, 20, 10] 从右向左取到第一个元素

Tuple（元组）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

—— 有序，不可变， 查找（T.index(value, start, end)), 遍历（列表，下标索引）

>>>tup1 = ('month', 'day', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

#创建空元组
tup1 = ();

注意：

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

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

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

? 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

1. 访问元组

? 元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = ('Google', 'baidu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])

1. 修改元组

   元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2;
print(tup3)

1. 删除元组

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

tuple = ('Google', 'baidu', 1997, 2000)

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

? 以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

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

enumerate() 方法

seasons = ['Spring', 'Summer', 'Autumn', 'Winter']
list(enumerate(seasons))
list(enumerate(seasons, start=1))       # 下标从 1 开始

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print(i, element)

Dictionary（字典）

字典是一种可变容器模型，且可存储任意类型对象。

? 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

? 键必须是唯一的，但值则不必。

? 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'A': '11111', 'B': '2222', 'C': '3333'}

— — key-value键值对。

? 创建（1. mdict={‘key‘:value}, 2.mdict=dict(key=value)）

? 插入：mdict[key] = value 获取：key获取value数据（get， pop）

? 查找：mdict[key], mdict.get(key), 遍历（安装mdict.keys（）遍历key，由mdict[key]获取value）

1. 访问字典里的值

? 把相应的键放入到方括号中，如下实例:

dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}

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

? 如果用字典里没有的键访问数据，会输出没有key错误：KeyError

1. 修改字典

   向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

dict = {'Name': 'Andy', 'Age': 37, 'Class': 'Hongkong'}

dict['Age'] = 48;  # 更新 Age
dict['School'] = "清华大学"  # 添加信息

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

1. 删除字典元素

   能删单一的元素也能清空字典，清空只需一项操作。

? 显示删除一个字典用del命令

del dict['Name']  # 删除键 'Name'
dict.clear()  # 清空字典
del dict  # 删除字典

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

? 这会引发一个异常，因为用执行 del 操作后字典不再存在

字典键特性

? 字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行

? 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

? 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

eg:

dict = {['Name']: 'Andy', 'Age': 37, 'Class': 'Hongkong'}

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

此时，就会出异常，TypeError: unhashable type: ‘list‘ 错误

其他使用方法

len(dict) 计算字典元素个数，即键的总数

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

Set （集合）

集合（set）是一个无序的不重复元素序列

可以使用大括号 { } 或者 set() 函数创建集合

集合对象还支持union(联合), intersection(交), difference(差)等操作。

作用：（1）去重 （2）运算：交集（intersection），并集(union)

>>>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', '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的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

同样集合支持集合推导式

>>>a = {x for x in 'abcbde' if x not in 'abc'}
>>> a
{'d', 'e'}

1. 添加元素

   s.add( x )
   

? 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>>thisset = set(("baidu", "Alibaba", "Tenxun"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Tenxun', 'Facebook', 'baidu', 'Alibaba'}

? 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等

? 语法格式如下：

s.update( x )       # x 可以有多个，用逗号分开。

>>>thisset = set(("Google", "baidu", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'baidu'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'baidu'}

1. 移除元素

   s.remove( x )
   

? 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>>thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>>thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

? 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误，如下discard函数

   s.discard( x )

1. 清空集合

   s.clear()
   

2. 判断元素 x 是否在集合

   x in s
   

? 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False

1. 集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

Queue (队列)

? Queue是python标准库中的线程安全的队列（FIFO）实现,提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者和消费者线程之间的信息传递

— 存储先进先出的对象

? 创建方式：mq = queue.Queue(maxsize=0)

? 插入：put， put_nowait, 取数据：get, get_nowait

from queue import Queue #LILO队列
q = Queue() #创建队列对象
q.put(0)    #在队列尾部插入元素
q.put(1)
q.put(2)
print('LILO队列',q.queue)  #查看队列中的所有元素
print(q.get())  #返回并删除队列头部元素
print(q.queue)

from queue import LifoQueue #LIFO队列
lifoQueue = LifoQueue()
lifoQueue.put(1)
lifoQueue.put(2)
lifoQueue.put(3)
print('LIFO队列',lifoQueue.queue)
lifoQueue.get() #返回并删除队列尾部元素
lifoQueue.get()
print(lifoQueue.queue)

from queue import PriorityQueue #优先队列
priorityQueue = PriorityQueue() #创建优先队列对象
priorityQueue.put(3)    #插入元素
priorityQueue.put(78)   #插入元素
priorityQueue.put(100)  #插入元素
print(priorityQueue.queue)  #查看优先级队列中的所有元素
priorityQueue.put(1)    #插入元素
priorityQueue.put(2)    #插入元素
print('优先级队列:',priorityQueue.queue)  #查看优先级队列中的所有元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue)
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue)  #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue)  #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('删除后剩余元素',priorityQueue.queue)  #删除后剩余元素
priorityQueue.get() #返回并删除优先级最低的元素
print('全部被删除后:',priorityQueue.queue)  #查看优先级队列中的所有元素

from collections import deque   #双端队列
dequeQueue = deque(['Eric','John','Smith'])
print(dequeQueue)
dequeQueue.append('Tom')    #在右侧插入新元素
dequeQueue.appendleft('Terry')  #在左侧插入新元素
print(dequeQueue)
dequeQueue.rotate(2)    #循环右移2次
print('循环右移2次后的队列',dequeQueue)
dequeQueue.popleft()    #返回并删除队列最左端元素
print('删除最左端元素后的队列：',dequeQueue)
dequeQueue.pop()    #返回并删除队列最右端元素
print('删除最右端元素后的队列：',dequeQueue)

Collections

? Counter， defaultdict， deque， namedtuple， OrderedDict

? 见下节《2-Collections库使用》

6.3 自定义类型

自定义类型：类

类是一种高级抽象,就是一种高级的数据类型,是对象的蓝图,就是用来定义你要用的对象的属性和行为的

class MyClass:
    """一个简单的类实例"""
    i = 12345

    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())