码迷,mamicode.com
首页 > 编程语言 > 详细

python数据类型

时间:2019-05-27 11:47:48      阅读:21      评论:0      收藏:0      [点我收藏+]

标签:kong   函数名   googl   输出   优先级队列   有一个   规范   alibaba   浮点型   

python数据类型

Date: 2019-04-20

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())

python数据类型

标签:kong   函数名   googl   输出   优先级队列   有一个   规范   alibaba   浮点型   

原文地址:https://www.cnblogs.com/sunBinary/p/10929856.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!