python定义变量列表_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