python数据类型

时间  2019-11-16
标签 python 数据 类型 栏目 Python 繁體版
原文   原文链接

Date: 2019-05-27html

Author: Sunjava

1. 自省机制

什么是自省？python

自省（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()　app

​ 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 sun'

      print(a)

    ​ 输出：

    ​ My name‘s sun

    ​ 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-八、utf-1六、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

《— 《— 《---

一、追加：names.append()

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

二、删除：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']

​

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

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

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

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

五、反转：reverse()

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

六、清空：clear()

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

七、插入：insert()

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

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

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

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

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

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

十、对列表进行切片处理

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())
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程