python定义类super python定义类型变量

Python中，能够直接处理的数据类型有以下几种：

整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的(除法难道也是精确的？是的！)，而浮点数运算则可能会有四舍五入的误差。

字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。当然单引号‘和双引号"本身也是字符，如果字符串中有单引号'或双引号"则按照如下的方法处理

字符串的方法

name.capitalize() 首字母大写
name.casefold() 大写全部变小写
name.center(50,"-") 输出 '---------------------Alex Li----------------------'name.count('lex') 统计 lex出现次数
name.encode() 将字符串编码成bytes格式
name.endswith("Li") 判断字符串是否以 Li结尾"Alex\tLi".expandtabs(10) 输出'Alex Li'， 将\t转换成多长的空格
name.find('A') 查找A,找到返回其索引， 找不到返回-1format :>>> msg = "my name is {}, and age is {}"
>>> msg.format("alex",22)'my name is alex, and age is 22'
>>> msg = "my name is {1}, and age is {0}"
>>> msg.format("alex",22)'my name is 22, and age is alex'
>>> msg = "my name is {name}, and age is {age}"
>>> msg.format(age=22,name="ale")'my name is ale, and age is 22'format_map>>> msg.format_map({'name':'alex','age':22})'my name is alex, and age is 22'msg.index('a') 返回a所在字符串的索引'9aA'.isalnum() True'9'.isdigit() 是否整数
name.isnumeric
name.isprintable
name.isspace
name.istitle
name.isupper"|".join(['alex','jack','rain'])'alex|jack|rain'maketrans>>> intab = "aeiou" #This is the string having actual characters.
>>> outtab = "12345" #This is the string having corresponding mapping character
>>> trantab =str.maketrans(intab, outtab)>>>
>>> str = "this is string example....wow!!!"
>>>str.translate(trantab)'th3s 3s str3ng 2x1mpl2....w4w!!!'msg.partition('is') 输出 ('my name', 'is', '{name}, and age is {age}')>>> "alex li, chinese name is lijie".replace("li","LI",1)'alex LI, chinese name is lijie'msg.swapcase 大小写互换>>> msg.zfill(40)'00000my name is {name}, and age is {age}'
>>> n4.ljust(40,"-")'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")'-----------------------------Hello 2orld'
>>> b="ddefdsdff_哈哈"
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值(请注意大小写)，也可以通过布尔运算计算出来

空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

变量

变量即在程序运行过程中它的值是允许改变的量

变量的作用：代指内存里某个地址中保存的内容

变量定义的规则：

变量名只能是 字母、数字或下划线的任意组合

变量名的第一个字符不能是数字

以下关键字不能声明为变量名

['and', 'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally',
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not',
'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with',
'yield']

变量不仅可以是数字，还可以是任意数据类型

变量的赋值

#!/usr/bin/env python#-*- coding: utf-8 -*-
name= "sunny" # name是字符串age=24 #age是整数

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359

list

list是一种有序的集合，可以随时添加和删除其中的元素

创建一个列表

list1=[1, 2, 3, 4, 5 ]

查看列表

list1

列表元素的个数

len(list1)

用索引来访问list中每一个位置的元素，记得索引是从0开始的

>>> list1[0]
1
>>> list1[-1]
5

查找列表中值为3元素的索引

list1.index(3)

在列表末尾添加新的元素

list.append(8)

插入元素到指定位置

list1.insert(2,'hehe')

移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

list1.pop()

list1.pop(2)

删除指定元素

list1.remove(3)

替换元素

list1[0]=4

排序

list1.sort()

反转

list1.reverse()

统计某个元素在列表中出现的次数

list1.count('hehe')

在列表末尾追加另一个列表

list1.extend(list2)

返回列表元素最大值

max(list1)

返回列表元素最小值

min(list1)

切片

list1[0:5]

判断某个值是否在列表中

if 5 inlist1:print("true")

删除列表

del list1

tuple

tuple和list非常类似，但是tuple一旦初始化就不能修改

创建一个元组

tup1 = (1, 2, 3, 4, 5 )

只有1个元素的tuple定义时必须加一个逗号,

tup2= (1,)

将元组转为列表

list2=list(tup1)

将列表转为元组

tup2=tuple(list2)

删除元组

del tup1

dict

使用键-值(key-value)存储，具有极快的查找速度 。dict是无序的 key是唯一的

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} #生成一个字典>>> d['Michael'] #通过key查询对应的值95
>>> d['Adam'] = 67 #向字典中插入新值
>>> d['Adam']67
>>> d['Jack'] = 90
>>> d['Jack']90
>>> d['Jack'] = 88 #多次对一个key放入value，后面的值会把前面的值冲掉
>>> d['Jack']88>>>d['Thomas'] #key不存在，dict就会报错
Traceback (most recent call last):
File"", line 1, in KeyError:'Thomas'
>>> 'Thomas' ind #通过in判断key是否存在
False
>>>d.get('Thomas') #如果key不存在，可以返回None，并不会报错
>>> d.pop('Bob') #删除一个key，用pop(key)方法，对应的value也会从dict中删除
75

循环打印

#方法1 这种速度快，大数据用这种
for i in dic:
print i,dic[i]
#方法2
for k,v in dic.items():
print k,v
dic.items()
取key
dic.keys()
['key2', 'key1']
取值
dic.values()
['sxl1', 'sxl']

随机删，慎重使用

dic.popitem()

如果没有这个key，就设置一个默认的值

dic.setdefault('name','sun')

将2个字典聚合，如果有重复数据将被覆盖

dic.update(a)

清空字典

dic.clear()

删除字典

del dic

浅复制，将字典复制一份

b=dic.copy()
set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

>>> s = set([1, 2, 3])>>>s
{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

重复元素在set中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])>>>s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)>>>s
{1, 2, 3, 4}>>> s.add(4)>>>s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

>>> s.remove(4)>>>s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])>>> s2 = set([2, 3, 4])>>> s1 &s2
{2, 3}>>> s1 |s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

difference 差异比较

l1 = ['1','2','3','4']
l2= ['4','5','6']
s1= set(l1) #传入一个集合
s2= s1.difference(*l2)print(s1) 原集合并未改变print(s2) #最终返回一个新的集合，

#这个属性是通过对象本身与传入的元素进行对比，只要对象本身没有与传入元素相同的元素，则返回这个元素，最终组合成新的元素集合

difference_update 差异更新
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = s1.difference_update(*l2)
print(s1)
print(s2)

#通过观察返回结果可知，这个方法是直接更新对象本身，就存在相同的元素剔除，并不会返回剔除元素，剔除规则，对象本身与传入元素对比，如果对象本身的元素在传入的元素里面，则删除这个元素

#{'3', '1', '2'}
#None
discard 删除一个元素
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
print(s1)
s2 = s1.discard('1')
print(s1)
print(s2)

#通过传入一个元素，对象本身则将这个元素删除，如果对象本身不存在这个元素则没有任何变化，也没有错误信息，该操作是直接操作对象本身，且没有返回值

#{'3', '2', '6', '4', '1'}
#{'3', '2', '6', '4'}
#None

intersection 取交集元素集合

l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection(s2)
print(s1)
print(s2)
print(s3)
#{'1', '2', '4', '3', '6'}  第一次原始集合
#{'1', '2', '4', '3', '6'}  集合s1和s2进行交集判断后的输出结果，并没有改变对象本身
#{'4', '5', '6'}    s2的集合也并未发生改变
#{'4', '6'}  通过交集比较，返回了一个新的元素集合，返回的是s1和s2共同拥有的元素集合
intersection_update 交集更新
l1 = ['1','2','3','4','6']
l2 = ['4','5','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.intersection_update(s2)
print(s1)
print(s3)
#通过输出结果可以看出，s1是直接更新了自己，把与传入的集合，与集合里面不相同的元素删除，且没有返回值
#{'6', '3', '4', '1', '2'}
#{'6', '4'}
#None
isdisjoint 判断是非没有交集
l1 = ['1','12']
l2 = ['4','6']
s1 = set(l1)
s2 = set(l2)
print(s1)
s3 = s1.isdisjoint(s2)
print(s1)
print(s3)
#{'12', '1'}
#{'12', '1'}
#True
#当两个集合之间没有任何交集时，则返回True
issubset 是否是子集
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
print(s1.issubset(s2))  #  输出为False说明s1不是s2的子集
print(s1.issubset(s3))  #  输出false说明 s1不是 s3的子集
print(s3.issubset(s1))  # 输出true，说明s3是s1的子集
issuperset 是否父集
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
print(s1.issuperset(s3))  #输出True,说明s1是s3的父集
print(s3.issuperset(s1))  #输出false，说明s3不是s1的父集
pop 随机删除元素
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.pop()
print(s1)   #对象本身被随机删除一个元素
print(s4)   #  随机删除的元素会返回被随机删除的元素
remove 移除指定元素
l1 = ['1','12','13']
l2 = ['4','6']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.remove('12')
print(s1)  #直接移除指定元素，并更新对象本身，如果指定元素不存在，则抛出异常
print(s4)  #  该属性没有返回值
symmetric_difference 差集对比
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference(s2)

print(s1)  #该方法并不会更新对象本身的值

print(s4)  #该对象返回一个新的集合，传入的元素与对象本身比较，如果传入的元素里面有的元素，而对象本身没有，则添加到对象本身的集合内，最终返回一个新的集合

symmetric_difference_update 差集更新
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
print(s1)
s4 = s1.symmetric_difference_update(s2)
print(s1)  #直接扩展对象本身与传入集合的没有交集的元素
print(s4)  #该方法没有返回值
union 返回新集合
#效果与差异更新类似，只是这个是返回一个新的集合，而差异更新是更新对象本身，不返回新集合
l1 = ['1','12','13']
l2 = ['4','6','1']
s3=set(['1','13'])
s1 = set(l1)
s2 = set(l2)
s4 = s1.union(s2)
print(s1)  #对象本身没有变化
print(s4)  #将对象本身与传入的集合元素比较，把所有的元素重现组合成一个新的集合返回
update 更新集合
dic1 ={'k1':'v1','k2':'v2'}
dic2 ={'k1':'vv','k2':'v2','k3':'v3'}
s1 = set(dic1)
print(s1)
s2 = s1.update(dic2)
print(s1)  #将会对集合本身进行扩展，如果对象本身不存在这个传入的元素，则添加到对象本身的元素集合
s = set([3,5,9,10]) #创建一个数值集合
t= set("Hello") #创建一个唯一字符的集合
a= t | s #t 和 s的并集
b= t & s #t 和 s的交集
c= t – s #求差集(项在t中，但不在s中)
d= t ^ s #对称差集(项在t或s中，但不会同时出现在二者中)

基本操作：

t.add('x') #添加一项
s.update([10,37,42]) #在s中添加多项

使用remove()可以删除一项：

t.remove('H')
len(s)
set 的长度
xins
测试 x 是否是 s 的成员
xnot ins
测试 x 是否不是 s 的成员
s.issubset(t)
s<=t
测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s>=t
测试是否 t 中的每一个元素都在 s 中
s.union(t)
s|t
返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)
s&t
返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t)
s-t
返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t)
s^t
返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()
返回 set “s”的一个浅复制
有序字典(orderedDict )

import collections
mydic= collections.OrderedDict(name='zcy',age='25',job='IT')
print(mydic)
print(mydic.keys())
print(mydic.values())
mydic.update(name='hello')
mydic.update(time='2016')
print(mydic)
#OrderedDict([('age', '25'), ('name', 'zcy'), ('job', 'IT')])
#odict_keys(['age', 'name', 'job'])
#odict_values(['25', 'zcy', 'IT'])
#OrderedDict([('age', '25'), ('name', 'hello'), ('job', 'IT'), ('time', '2016')])
View Code
默认字典(defaultdict)

import collections
mydic=collections.defaultdict(list)
print(mydic)
mydic['k1']
print(mydic)
print(mydic.keys())
print(mydic.values()) #默认值为一个列表类型
newdic={}
newdic.setdefault('k1',list)
newdic['k1']
print(newdic)
print(newdic['k1'])
print(newdic.values())
#defaultdict(, {})
#defaultdict(, {'k1': []})
#dict_keys(['k1'])
#dict_values([[]])
#{'k1': }
##dict_values([])
View Code
可命名元组(namedtuple)

importcollections
Point= collections.namedtuple('Point',['x','y','z']) #创建一个类,类名为Point
myPoint= Point(11,22,33)print(myPoint)print(myPoint.x) #直接通过命名元素去访问元组对应的元素,
print(myPoint[0]) #等同于上面这种方式,但是没有上面这种方式可读性强
print(myPoint.y)print(myPoint.z)#Point(x=11, y=22, z=33)#11#11#22#33
View Code

双向队列(deque)

importcollections
newqueue= collections.deque(['a','b','c'])print(newqueue)
newqueue.append(['d1','d2']) #追加一个元素到队列
print(newqueue)
newqueue.appendleft('a1') #追加一个元素到队列左侧
newqueue.appendleft('a2') #追加一个元素到队列左侧
print(newqueue)
newc= newqueue.count('a') #对队列某个元素进行计数
print(newc)
newqueue.extend(['e','f','g']) #扩展队列元素
print(newqueue)
newqueue.extendleft(['a11','a22','a33']) #从左侧开始扩展队列
print(newqueue)
newqueue.insert(2,'aa22') #插入到下标2的位置
print(newqueue)
newqueue.reverse()#顺序反转
print(newqueue)
newqueue.rotate(4) #将队列末尾4个元素反转到队列左侧
print(newqueue)#deque(['a', 'b', 'c'])#deque(['a', 'b', 'c', ['d1', 'd2']])#deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2']])#1#deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])#deque(['a33', 'a22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])#deque(['a33', 'a22', 'aa22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])#deque(['g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2', 'a11', 'aa22', 'a22', 'a33'])#deque(['a11', 'aa22', 'a22', 'a33', 'g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2'])
View Code

单项队列

#单向队列是FIFO工作模式
importqueue
newqueue= queue.Queue(2) #设置队列长度为2,也就是队列里只有两个任务
newqueue.put(['1','2']) #放入一个任务
newqueue.put(2) #放入第二个任务
isempty = newqueue.empty() #判断队列是否空
isfull = newqueue.full() #判断队列是否满了
get1 = newqueue.get() #获取第一个任务
get2 = newqueue.get() #获取第二个任务
print(get1)print(get2)
isfull2= newqueue.full() #判断队列是否满了,因为已经把任务取出来了,所以这时队列应该是没有满
isempty2 = newqueue.empty() #判断队列是否为空
print(isfull)print(isfull2)print(isempty)print(isempty2)#['1', '2']#2#True#False#False#True
queue 单向队列
View Code