文本输入,5种数据类型

图片 1

1.abs()

取数字的绝对值

>>> print(abs(-28))
28
>>> print(abs(-2.34))
2.34
>>> print(abs(1/3))
0.3333333333333333

一、变量和表达式

Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典

 

目录

Pycharm使用技巧(转载)

Python第一天  安装  shell  文件

Python第二天  变量  运算符与表达式  input()与raw_input()区别  字符编码  python转义符  字符串格式化

Python第三天 序列  5种数据类型  数值  字符串  列表  元组  字典

Python第四天   流程控制   if else条件判断   for循环 while循环

Python第五天   文件访问    for循环访问文件    while循环访问文件   字符串的startswith函数和split函数

Python第六天   类型转换

Python第七天   函数  函数参数   函数变量   函数返回值  多类型传值    冗余参数   函数递归调用   匿名函数   内置函数   列表表达式/列表重写

Python第八天  模块   包   全局变量和内置变量__name__    Python path

Python第九天  面向对象  类定义   类的属性    类的方法    内部类   垃圾回收机制   类的继承 装饰器

Python第十天   print >> f,和fd.write()的区别    stdout的buffer  标准输入 标准输出  标准错误   重定向 输出流和输入流

Python第十一天    异常处理  glob模块和shlex模块    打开外部程序和subprocess模块  subprocess类  Pipe管道  operator模块   sorted函数   生成器  walk模块   hashlib模块

Python第十二天     收集主机信息     正则表达式  无名分组   有名分组

Python第十三天   django 1.6   导入模板   定义数据模型   访问数据库   GET和POST方法    SimpleCMDB项目   urllib模块   urllib2模块  httplib模块  django和web服务器整合  wsgi模块   gunicorn模块

Python第十四天 序列化  pickle模块  cPickle模块  JSON模块  API的两种格式

Python第十五天  datetime模块 time模块   thread模块  threading模块  Queue队列模块  multiprocessing模块  paramiko模块  fabric模块  

 

 

 

 

5种数据类型
数值
字符串 (序列)
列表(序列)
元组(序列)
字典(可迭代对象)

 

 

序列
序列:字符串、列表、元组
序列的两个主要特点是索引操作符切片操作符

  • 索引操作符让我们可以从序列中抓取一个特定项目
  • 切片操作符让我们能够获取序列的一个切片,即一部分序列

序列的基本操作

  1. len(): 求序列的长度
  2. : 连接2个序列
  3. *: 重复序列元素
  4. in/not in: 判断元素是否在序列中
  5. max(): 返回最大值
  6. min(): 返回最小值
  7. cmp(x, y):比较两个序列是否相等 返回值大于0 ,等于0,小于0
    cmp:按照字符串比较,字符串比较的原则就是一个字符一个字符的比较,字符按照ASCII码来比较,字符1比字符2小,所以gene1001小于gene2。

 


数值类型

  • 整型  2^32个数字,范围-2,147,483,648到2147483647
  • 长整型  区分普通整型,需要在整数后加L或l。2345L,0x34al
  • 浮点型  0.0,12.0,-18.8,3e 7
  • 复数型  - 3.14j,8.32e-36j

字符串''类型

字符串是不可变数据类型
有三种方法定义字符串类型
str = 'this is a string'
str = "this is a string"
str = '''this is a string'''  或 """this is a string"""
三重引号(docstring)除了能定义字符串还可以用作注释
python里面单引号和双引号没有任何区别

n:换行
str = "this is a nstring"

字符串索引
字符串是序列,可以通过索引取每个字符
加号 :字符串连接符
str = 'abcde'
str[0] str[1]
字符串切片
str[start:end:step]
step:为负数表示从右向左,步长为正数,start那个数字的值不要,步长为负数,end那个数字的值不要

>>> str[1:3]
'bc'
>>> str[:3]
'abc'
>>> str[3:]
'de'
>>> str[::1]
'abcde'
>>> str[::2]
'ace'
>>> str[-1]
'e'
>>> str[-4:-1]
'bcd'
>>> str[-2:-4:-1]
'dc'

字符串相关函数
replace()
split()
join()
strip()
format()  :'{0},I'm {1},my E-mail is {2}'.format('Hello','Hongten','hongtenzone@foxmail.com')
find()


元组()类型
元组和列表十分相似
元组和字符串一样是不可变的,不可变的意思是元组里面的元素不能修改,比如a[-1] = xx 会报错

1.什么是树的度?树有两种存储结构:线性存储和链式存储2.python常用的第三方库?机器学习:MXNet、Tensorflow、PyTorch图形库:Aracda、PIL………………3.python中format用法:("{:*^20,.2f}".format())--表示“*”填充,居中,域宽20,千分号“,”分隔,保留小数点后两位4.常见字符编码范围:汉字:[0x4e00,0x9fa5]数字:[0x30,0x39]小写字母:[0x61,0x7a]大写字母:[0x41,0x5a]其他:除上所有5.default-默认值/reverse-反向/unhashable-不可使用的6.软件概要设计基本任务:设计软件系统结构数据结构及数据库设计编写概要设计文档概要设计文档评审7.print(0.1 0.2==0.3)----False解析:0.1 0.3=0.300000000000000048.Python字符编码可使用ASCII和Unicode编码,但Python字符编码用Unicode编码存储。9.a=10.99print(complex(a))---------(10.99 0j)-----------10.条件11=2233是合法的,输出True11.字典的键不能是列表类型,可以是元组类型,字典的值可以是列表类型12.D:PythonTesta.txt路径名错误,因为“”是转义字符,需要写成“\”13.算法复杂度:时间和空间//时间复杂度指算法执行过程所需最基本的执行次数,空间复杂度指执行算法所需存储空间//时间复杂度与计算机运行速度无关,空间复杂度与存储结构无关//数据处理效率与数据存储结构有关14.线性表、向量、栈、队列都属于线性结构15.循环链表是另一种形式的链式存储结构16.软件生命周期:从提出概念到不能使用退役为止整个过程都属于软件生命周期17.软件应首先满足用户功能需求,如果做不到这一点,什么产品都没有意义18.软件测试及调试:测试方法:静态测试、动态测试、黑盒测试、白盒测试、灰盒测试、功能测试、性能测试、单元测试、集成测试、系统测试、验收测试调试方法:强行排错法、回溯法、原因排除法19.文件操作中,使用with打开文件,文件在语句结束后会自动关闭文件,所以不用再次使用close()函数20.替换或者删除字符串中指定字符:replace()、strip()、切片操作等等。21.用切片方法使列表逆序:ls[::-1]22.形如列表list=[(1,1),(2,2),……,(9,9)]在进行索引时,未必免出现“超出范围”的错误,采用如下方法解决:s1,g1=list[0]###变量个数=列表或序列内元素个数,否则会出错###s2,g2=list[1]print(s1,g1,s2,g2)其中s1=list[0][0],s2=list[1][0],g1=list[0][1],g2=list[1][1]效果等价于:s1=list[0][0]g1=list[0][1]s2=list[1][0]g2=list[1][1]23.数据与数据间联系的模型:关系模型采用二维表表示,简称表。24.字符串、列表、元组类型都属于序列类型,字典属于映射类型。25.文件是存储在辅助存储器上的一组数据序列,可以包含任何数据内容。26.文件读取时,解码异常的解决办法:错误原因:Python3才会出现这样的问题,python3在readlines里缺省会使用当前系统的编码来解析文件,比如windows就用GBK,linux就用language。解决办法:在open()函数中加参数,例如:fi=open("somefile.txt","r")改为fi=open("somefile.txt","rt",encoding="utf-8")其中encoding指定编码格式27.join()函数用法,sep是序列类型,str是分隔符号:"str".join(sep)28.writelines()方法可以将一个列表类型的元素连接起来,写入文件:fo.writelines(sep)29.从列表中随机选取元素的方法:random.randint(0,4)random.choice(sep)考试优选第一种30.树中的节点数等于所有节点的度之和再加一31.程序异常和错误是完全不同的概念,异常通常指外部输入出错,错误通常指程序本身无法满足要求。32.Python脚本程序发生异常如果不及时处理,结果不可预测。33.可选参数放在非可选参数后面:正确:deffunc(a,b=2)错误:deffunc(b=2,a)deffunc(b=2,**a)带有“*”为可扩展的参数,*a表示接收一系列实参组成元组,**a表示接收一系列参数的实参名和值组成字典。34.CSV文件主要用于不同程序间的数据交换。35.用单纯open()方式打开文件,一定要用close()关闭文件,不然程序评分会失败。36.eval(input())可以解析输入的列表:“[4,5,2]”37.lstrip()函数删除左边空格,rstrip()删除右边空格38.print("转换成二进制数是:{:b}".format(num))39.turtle.color("red","yellow")参数1:轮廓颜色参数2:填充颜色40.seek()设置文件读取位置,tell()返回当前文件读取位置41.ascii()函数返回一个可打印的对象字符串表示,如果是非ascii字符就会输出x,u,U等字符来表示,与python2版本中repr()等效42.string.title(),将字符串标题化,即首字母大写。string.capitalize(),字符串的第一个字符大写。43.set()函数创建集合数据类型对象,list(set(sep))可以去除列表元素中的重复项。44.用str[::-1]的方法实现字符串的反转45turtle.done()函数用法,用于turtle结束,关闭turtle。turtle.hideturtle()隐藏画笔形状。46.python代码编写允许在一行末尾添加“;”不会出现语法错误,但一般不这样做,影响代码美观。47.1//(1/10)其结果等于“9.0”,因为浮点数精度问题,0.1相当于0.1*****,不能准确表示,所以1//0.1==1//0.1*****,等于9.048.UTF-8编码汉字占用3个字节,GBK和CP963编码中汉字占用2个字节。49.python内置函数不需要导入,所以math不属于内置函数,属于标准库。50.data=eval(input()),如果输入“8,78,90,520”,则data=(8,78,90,520)51.a,b,c=[int(x)forxininput().split(",")]输入三个以逗号分隔的数,以逗号分隔形成列表,遍历循环将字符串类型转换成数字类型。52.ls1=[1,2,3,4,5]ls2=ls1ls2.reverse()print(ls1)结果为[5,4,3,2,1],因为列表对象的赋值就是简单的引用。所以ls1与ls2指向同一内存单元,也即对ls2的操作与对ls1操作同效。53.time库的用法-----ps:详细内容自行百度经过数天的奋斗,终于把模拟题给弄完了,个人总结了一些经验和易错点,虽然不多,但很实用,应付二级考试应该是没有问题,但是还需要多多刷题,提高熟练度!!!请多指教www

2.dict()

用于创建字典

>>> dict()     #创建空字典
{}
>>> dict(a='who',b='while',c='whit')   #传入关键字创建字典
{'b': 'while', 'c': 'whit', 'a': 'who'}
>>> dict(zip([1,2,3],['one','two','three']))  #映射函数方式创建字典
{1: 'one', 2: 'two', 3: 'three'}
>>> dict([(1,'one'),(2,'two'),(3,'three')])  #可迭代对象方式创建字典
{1: 'one', 2: 'two', 3: 'three'}

复制代码 代码如下:

- 元组可以存储一系列的值

元组通常用在用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变。

创建元组
t= ()
t= (2,) 一定要加逗号才是元组,否则会当普通字符串对待
t = ('james', 'M')
t = ('james', 'M',(1,)) 元组里面包含元组
j = 'sd'
t = (j, 'M') 包含变量

print t
('sd', 'M')

文本输入,5种数据类型。print t[0] 返回第一个元素

 

元组操作

  • 元组和字符串一样属于序列类型,可以通过索引和切片操作
  • 元组值不可变
    元组的拆分

    t = (1,2,3) a, b, c = t a 1 b 2 c 3

 

 

M=2
t = ('james', M,'gg','cc')
for a in t:
    print a
james
2
gg
cc

 

 b=('a','b','a','d','a')
print(b.count('a'))  统计'a'这个元素一共有多少个


列表[]类型

列表(list)是处理一组有序项目的数据结构,即可以在列表中存储一个序列的项目。
列表是可变类型的数据类型
创建列表
list1 = []
list2 = list()   list()函数
list3 = ['a',1,2]
list4 = ['a',1,(1,),['sdf','sww]]

对某项目赋值,下标从0开始
list3[0] = 'b'

列表操作

  • 取值
    切片和索引

    切片 l = list(range(10)) l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l[5:0:-1] 输出:[5, 4, 3, 2, 1] l[5:4:-1] 输出:[5] l[:3:-1] 输出:[9, 8, 7, 6, 5, 4] l[0:3:-1] 输出:[] l[9::-1] 输出:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] l[-2:]( l[-2:10:1]) 输出:[8, 9] l[2:]( l[2:10:1]) 输出:[2, 3, 4, 5, 6, 7, 8, 9] l[:-2]( l[0:-2:1]) 输出:[0, 1, 2, 3, 4, 5, 6, 7] l[0] 输出:0

    l[列表最小值:列表最大值:步进] 步长为正数情况下输出不包含列表最大值 列表最小值下标从0开始 -1:9 -2:8

- 添加
list.append()
list1[2].append('abc')  如果列表里面又有列表使用下标来访问
添加 list= list [6]  ,list2 =[1,2]   list = list list2

  • 删除
    del list[x] 删除某个元素  del list 删除整个列表
    list.remove(列表里面实际的值)
  • 修改
    list[] = x
  • 查找
    var in list
  • 插入
    list.insert(list[x],object)  在下标前插入一个对象
  • 排序
    list.sort()
  • 反转
    list.reverse()
  • 弹出
    list.pop([index])  返回一个元素并删除这个元素,参数是下标,没有参数会删除最后一个元素
  • 扩展
    list.extend(iterable)  可迭代的,相比append()方法可以追加多个值,l.extend(range(10))
  • 统计
    a = ['s','c','c']
    a.count('c')  统计'c'这个元素一共有多少个

 

Python合并列表,append()、extend()、 、 =
1.append() 向列表尾部追加一个新元素,列表只占一个索引位,在原有列表上增加
2.extend() 向列表尾部追加一个列表,将列表中的每个元素都追加进来,在原有列表上增加
3. 直接用 号看上去与用extend()一样的效果,但是实际上是生成了一个新的列表存这两个列表的和,只能用在两个列表相加上
4. = 效果与extend()一样,向原列表追加一个新元素,在原有列表上增加

图片 2


 

字典{}类型

字典是python中的唯一的映射类型(哈希表)
字典对象是可变的,但是字典的键必须使用不可变对象,一个字典中可以使用不同类型的键值。
跟redis的set类型一样,字典里的key不能重复,赋值的时候如果发现已有key则替换
字典的方法:

  • keys() 返回所有key
  • values() 返回所有value
  • items() 返回一个列表,key和value在一个元组里

创建字典
dic = {}
dic = dict()

dict()函数
help(dict)

 

字典创建
第一种
dict((['a',1],['b',2]))  #dict()函数方式1
aa=dict((['a',1],['b',2]))
print aa
{'a': 1, 'b': 2}

第二种
dict(a=1, b=2)  #dict()函数方式2
bb=dict(a=1, b=2)
print bb
{'a': 1, 'b': 2}

第三种
dd = {'line':1,'char':2,'word':3} 或dd = {1:1,2:2,3:3} 
print dd

{'char': 2, 'line': 1, 'word': 3}

第四种
info = {}  #创建一个空字典
info['name'] = 'name'
info['age'] = 'age'
info['gender'] = 'gender'
print info
{'gender': 'gender', 'age': 'age', 'name': 'name'}

 

 

fromkeys()函数
fromkeys(S[,v]) S指定一个序列,v指定value的值,默认为None。
dic.fromkeys(range(3),100)
In [4]: dic.fromkeys(range(3),100)
Out[4]: {0: 100, 1: 100, 2: 100}
fromkeys函数创建的字典需要赋值到另一个字典才能保存
ddict = {}.fromkeys(('x','y'), 100)

 

update()函数
将一个字典添加到另一个字典
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict1.update(dict2)
print "dict1 : %s" %  dict1

 

get()函数
将代入key,返回value
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.get('Age')
print "dict1 : %s" %  dict1  返回7

 

pop函数  删除字典里某个key值
dict1 = {'Name': 'Zara', 'Age': 7}
dict1.pop('Age')
print dict1

 

zip函数 dict函数 接受任意多个(包括0个和1个)序列作为参数,返回一个tuple列表
x = [1, 2, 3]
y = ['a', 'b', 'c']
xyz = zip(x, y,)
print xyz
print dict(xyz)

 

访问字典
直接使用key访问:key不存在会报错,可以使用has_key()或者in和not in判断。
循环遍历  items()  ,iteritems()函数
例:
for i in dic.keys():
for i in dic:
print i 读取的是key
print dic[i] 读取的是value

for i, o in dic.items():
    print i, o

建议使用iteritems函数,items函数会一次性把字典的所有键值全部取出来,而iteritems函数只会一次取出一个

dict1 = {'Name': 'Zara', 'Age': 7}
for i, o in dict1.iteritems():
    print i, o

 

 

 

#!/usr/bin/python

info = {}  创建一个空字典
name = raw_input("Please input name: ")
age = raw_input("Please input age: ")
gender = raw_input('Please input (M/F): ')
info['name'] = name
info['age'] = age
info['gender'] = gender
for k, v in info.items():
print "%s: %s" % (k, v)
print 'main end'

 

 

容器(container)
容器是一种把多个元素组织在一起的数据结构,容器中的元素可以逐个地迭代获取,可以用 in , not in 关键字判断元素是否包含在容器中。通常这类数据结构把所有的元素存储在内存中(也有一些特列并不是所有的元素都放在内存)在Python中,常见的容器对象有:

list, deque, ....
set, frozensets, ....
dict, defaultdict, OrderedDict, Counter, ....
tuple, namedtuple, …
str


可迭代对象(iterable)
刚才说过,很多容器都是可迭代对象,此外还有更多的对象同样也是可迭代对象,比如处于打开状态的files,sockets等等。
但凡是可以返回一个 迭代器 的对象都可称之为可迭代对象


什么是迭代器呢?
它是一个带状态的对象,他能在你调用 next() 方法的时候返回容器中的下一个值,任何实现了 __next__() (python2中实现 next() )方法的对象都是迭代器


序列:字符串、列表、元组
序列跟迭代器不一样,序列对象没有next()方法


生成器(generator)
生成器算得上是Python语言中最吸引人的特性之一,生成器其实是一种特殊的迭代器,不过这种迭代器更加优雅。
它不需要再像上面的类一样写 __iter__() 和 __next__() 方法了,只需要一个 yiled 关键字。 因此任何生成器也是以一种懒加载的模式生成值。,因此任何生成器也是以一种懒加载的模式生成值。

例如数据库的全局唯一ID生成器,也是一种生成器


生成器是迭代器,但是迭代器不一定是生成器,因为生成器是有状态的!!!!!!

 

3.help() 

用于查看函数或模块用途的详细说明

>>> help('sys')   #查看sys模块的帮助
>>> help('str')   #查看str数据类型帮助信息
>>> a = [1,2,3]  
>>> help(a)       #查看列表list帮助信息
>>> help(a.extend)   #显示list的extend方法的帮助信息

>>> 1 1              
2
>>> print 'hello world'
hello world
>>> x = 1              
>>> y = 2
>>> x y
3

4.min()

返回给定参数的最小值,参数可以为列表,元组,字典和集合

>>> print(min(1,23,4))     #给定序列的最小值,这里实际上判断的元组类
1
>>> print(min([1,2,3,4]))   #列表
1
>>> print(min((3,4,5)))   #元组
3
>>> print(min({'a':3,'b':44,'c':22}))  #字典,对字符串按ascii码位置判断
a
>>> print(min({22,33,44}))   #集合判断
22

Python是强类型语言,无法根据上下文自动解析转换成合适的类型。 Python是一种动态语言,在程序运行过程中,同一个变量名在运行的不同阶段可以代表不同形式的值(整型,浮点,列表,元组),变量名只是各种数据及对象的引用。C语言中的变量名是用来存放结果的内存片段。

5.setattr()

对应函数 getatt(),用于设置属性值,该属性必须存在

1、在Python中是通过对象的引用而不是值来赋值给变量的。

6.all()

判断给定的可迭代参数中所有元素不为0,空,False,返回True,否则返回False

>>> all([1,2,3])   #列表元素不为空或0返回True
True
>>> all([0,2,3])  #列表元素为0返回False
False
>>> all([1,'',3])  #列表元素为空返回False
False
>>> all([1,False,3])  #列表元素为False返回False
False
>>> all([])    #注意:空列表返回True
True
>>> all((1,2,3))  #元组元素都不为空或0返回True
True
>>> all((0,2,3))  #为0返回False
False
>>> all((1,'',3))   #为空返回False
False
>>> all(())    #注意:空元组返回True
True
>>> all((1,False,3))   #为False返回False
False

2、赋值操作符主要是"=",同时也可使用增量赋值,如 x =1。但是没有自增、自减操作符。

7.dir()

获取当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性,方法列表

>>> dir()   #获取当前范围内的变量,方法和定义的类型列表,
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'd1']
#带参数时返回参数的属性,方法列表
>>> dir(list)    #返回列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

3、在C语言中,赋值语句可以当作表达式(可以返回值),但是在Python中赋值语句不会返回值,如下面的就是非法的:

8.hex()

将数值转换成十六进制

>>> hex(16)   #将十进制转换成十六进制
'0x10'
>>> hex(-17)
'-0x11'
>>> hex(0o11)  #将八进制转换成十六进制
'0x9'
>>> hex(0b1100)  #将二进制转换成十六直接
'0xc'
>>> hex(0b10)
'0x2'
#说明:二进制表示(0b),八进制表示(0o),十六进制(0x)

复制代码 代码如下:

9.next()

返回迭代器的下一个项目,可在没有下一个项目时返回设置的默认值

>>> it = iter([1,2,3,4,5])   #使用iter生成迭代器
>>> next(it)   #返回一个可迭代数据结构中的下一个元素
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
4
>>> next(it)
5
>>> next(it)   #在没有下一个元素则会触发 StopIteration 异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> next(it,'no values')   #在没有下一个元素时返回指定默认值
'no values'

>>> x=1
>>> y=(x=x 1)

10.slice()

用来创建切片对象,可指定起始和结束位置,间隔

class slice(stop)

class slice(start,stop[,step])

>>> l1 = [1,2,3,4,5,6,7,8]
>>> slice1 = slice(5)   #定义一个切片对象,截取长度为5,不指定起始位置默认从索引0开始
>>> l1[slice1]    #列表引用切片对象
[1, 2, 3, 4, 5]
>>> slice3 = slice(1,6,1)   #定义一个切片对象,指定起始位置为1结束位置为6,间隔为1
>>> l1[slice3]    #当间隔为1时,相当于0间隔
[2, 3, 4, 5, 6]
>>> slice2 = slice(1,7,2)  #间隔为2时,相隔一个截取元素
>>> l1[slice2]
[2, 4, 6]

SyntaxError: invalid syntax
以 #! 开头的称为组织行,这行告诉你的Linux/Unix系统当你执行你的程序的时候,它应该运行哪个解释器。例如:#!/usr/bin/python

11.any()

判断可迭代参数是否全部为空或0或False则返回False,否则返回True。

>>> any([1,2,3])
True
>>> any([0,'',1])
True
>>> any([0,'',False])   #全部为空值才返回False
False
>>> any([])   #空列表返回False
False
>>> any((1,2,3))
True
>>> any((0,'',1))
True
>>> any((0,'',False))
False
>>> any(())   #空元组返回False
False

以 # 开头的称为注释行。

12.divmod(a,b)

返回a除以b的商和余数的元组(a//b,a%b)

>>> divmod(4,2)   #返回4除以2的商和余数
(2, 0)
>>> divmod(15,4)
(3, 3)
>>> divmod(2 0.2j,3 1.3j)   #不支持负数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't take floor or mod of complex number.
>>> divmod(4,8)  #当不被整除时余数返回4,不解!
(0, 4)
>>> divmod(4,9)
(0, 4)
>>> divmod(4,100)
(0, 4)

二、条件语句

13.id()

用于获取对象的内存地址

>>> id(1)
8956480
>>> id(2)
8956512
>>> id('b')
140349300904040
>>> a = 'python'
>>> id(a)
140349300975744

控制流语句:通过使用or,and,not关键字可以建立任意的条件表达式

14.object()

获取一个新的,无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
该函数时2.2.版本新增,2.3版本之后,该函数不接受任何参数。

if-elif-else:(Python 没有 switch-case 语句,可以通过 if 语句配合字典完成同样的工作)

15.sorted()

对所有可迭代的对象进行排序操作

sort 与 sorted 区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

语法:sorted(iterable, /, *, key=None, reverse=False)

iterable:可迭代对象

key:用来进行比较的元素,只有一个参数,指定可迭代对象中的一个元素来进行排序

reverse:排序规则,reverse=True为降序,reverse= False为升序(默认)

>>> sorted([-12,3,23,18])   #列表按数字排序
[-12, 3, 18, 23]
>>> sorted([-12,3,23,18],key=abs)  #列表数字按绝对值排序
[3, -12, 18, 23]
>>> sorted(['bc','aa','fd','cj'])   #列表字符按首字母的ASCII码排序
['aa', 'bc', 'cj', 'fd']
#如果是数字与字符混合,在python3需要指定key的函数对象
>>> l1 = [2,'a','b',4,-33,'python']
>>> l1
[2, 'a', 'b', 4, -33, 'python']
>>> sorted(l1,key=id)   #按内存地址排序
[2, 4, -33, 'a', 'b', 'python']
>>> sorted(l1,key=str)  #按字符串排序,对所有数据转换成字符串后首个字符按ASCII排序
[-33, 2, 4, 'a', 'b', 'python']
>>> ord('-')
45
>>> ord('2')
50
>>> ord('4')
52
>>> ord('a')
97
>>> ord('b')
98
>>> ord('p')
112
#如果需要排序的是一个列表嵌套元组,则需要使用参数key,指定关键字
>>> a = [('b',2),('a',1),('c',0)]
>>> sorted(a,key=lambda x:x[0])
[('a', 1), ('b', 2), ('c', 0)]
>>> sorted(a,key=lambda x:x[1])
[('c', 0), ('a', 1), ('b', 2)]

>>> tup1 = ('python','java','c  ','bash','php','perl','c#')
>>> tup1
('python', 'java', 'c  ', 'bash', 'php', 'perl', 'c#')
>>> sorted(tup1,key=str.lower)   #忽略大小写排序
['bash', 'c#', 'c  ', 'java', 'perl', 'php', 'python']
>>> sorted(tup1,key=str.lower,reverse=True)  #反向排序
['python', 'php', 'perl', 'java', 'c  ', 'c#', 'bash']

复制代码 代码如下:

16.ascii()

类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符

>>> ascii('bb')
"'bb'"
>>> ascii(' ')
"' '"
>>> ascii('中')
"'\u4e2d'"

if something == 1:   
    doSomething1()
elif something == 2:   
    doSomething2()
else:   
    pass # 表示一个空的块或者是空的主体,使用pass语句
while-else:
while something:   
    doSomething1()
else:   
    doSomething2()
for-else:
for i in range(1, 10, 2):   # i 值从 1 到 10,步长为2
    print i
else:
    print 'The for loop is over'

17.enumerate()

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

语法:enumerate(sequence,[start=o])

sequence:一个序列,迭代器或其他支持迭代对象

start:下标起始位置

>>> l1 = ['python','c  ','java','php','css']
>>> list(enumerate(l1))     #生成数据和数据下标
[(0, 'python'), (1, 'c  '), (2, 'java'), (3, 'php'), (4, 'css')]
>>> list(enumerate(l1,1))   #指定下标从1开始
[(1, 'python'), (2, 'c  '), (3, 'java'), (4, 'php'), (5, 'css')]

>>> l1 = ['python','c  ','java','php','css']
>>> for i,v in enumerate(l1):
...   print(i,v)
... 
0 python
1 c  
2 java
3 php
4 css

break 和 continue:用于中断和继续循环。

18.input()

用来获取交换输入,python3默认接受的是字符串

>>> in1 =input('inside:')
inside:123
>>> type(in1)   #默认接受字符串
<class 'str'>
>>> in2 =input('inside:')
inside:python
>>> type(in2)
<class 'str'>

三、文件的输入/输出

19.oct()

将一个整数转换成8进制字符串

>>> oct(10)   #十进制转八进制
'0o12'
>>> oct(0b1010)  #二进制转八进制
'0o12'
>>> oct(0xA)  #十六进制转八进制
'0o12'
>>> oct(3.3)   #不支持float浮点型转八进制
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> oct(0.1 1.2j)   #不支持complex复数转八进制
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'complex' object cannot be interpreted as an integer

复制代码 代码如下:

20.staticmethod()

返回函数的静态方法

f=open("foo.txt")
line=f.readline()
while line:
    print line,
    line=f.readline()  #读取一行,包括换行符'n',读到文件末尾,返回空字符串
f.close()

21.bin()

返回一个整数 int 或者长整数 long int 的二进制表示。可以将八进制,十进制,十六进制转换为二进制,不支持float类型

>>> bin(10)   #十进制转二进制
'0b1010'
>>> bin(10.1)  #float不支持转二进制
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> bin(0o10)  #八进制转二进制
'0b1000'
>>> bin(0xA)  #十六进制转二进制
'0b1010'

f=open("out.txt","w")
year=1
money=1000
while year<=5:
    money=money*(1 0.05)
    f.write("= %0.2fn" % (year,money)) # print>>f,"= %0.2f" % (year,money)
    year =1
f.close()

22.eval()

用来执行一个字符串表达式,并返回表达式的值。

>>> eval('123')
123
>>> a = eval('123')   #可以将数值字符串转换为int类型
>>> type(a)
<class 'int'>
>>> eval('2**8')  #将数值字符串当表达式并计算结果返回int类型
256
>>> eval("'a' 'b'")  #字符串运算,必须这么写
'ab'
>>> eval("'a'*5")  #必须这么写,5不能加引号否则报错
'aaaaa'
>>> eval("'a'*'5'")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'

for line in f.xreadlines():
    # Do something with line

23.int()

用于将一个字符串数值或数字转换为整形

>>> int()     #不传入参数结果为0
0
>>> a =int('2')    #将字符串转换成int类型
>>> type(a)
<class 'int'>
>>> a
2
>>> int(2.6)    #将浮点型转换为整型
2
>>> b =int('12',16)  #以字符串的十六进制转换为十进制
>>> type(b)
<class 'int'>
>>> b
18
>>> int('0xC',16)  #可以这样写十六进制
12
>>> int('10',8)   #八进制转十进制
8
>>> int('0o10',8)
8
>>> int('0b1000',2)  #二进制转十进制
8
>>> int('1000',2)   #可以省略进制表示法
8

四、内建类型

24.open()

用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写

>>> f = open('aa.txt','r ')   #以读写方式打开一个文件
>>> f.write('hello pythonn')  #写入内容到文件中
13
>>> f.flush()   #刷新文件内容
>>> f.tell()   #查看指针位置
13
>>> f.seek(0)  #移动文件指针到起始位置
0
>>> f.tell()   #查看指针
0
>>> f.readline()  #根据指针位置返回一行文件内容
'hello pythonn'
file1 = open('aa.txt','a ',1) #以追加写的模式打开文件,1表示行缓冲,如为0则不缓冲,大于1时表示缓冲区大小,为负数时使用系统默认值。

4.1 None类型

25.str()

将字节转换成字符串,bytes() 将字符串转换为字节

>>> s1=str(11)
>>> type(s1)   #将对象转换成字符串
<class 'str'>

>>> bytes('中',encoding = 'utf-8')   #将字符串转换bytes字节
b'xe4xb8xad'
>>> str(b'xe4xb8xad',encoding = 'utf-8')  #将字节转换为字符串
'中'

>>> bytes()  #生成空字节对象
b''

None表示空对象。如果一个函数没有显示的返回一个值,None就被返回。None的bool值为false

26.bool()

判断给的参数是否为真,则返回True,否则返回False

>>> bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> bool(False)
False
>>> bool(True)
True
>>> bool('')
False
>>> bool('a')
True
>>> bool(None)
False
>>> bool("")
False
>>> bool([])
False
>>> bool(())
False
>>> bool({})
False

4.2 数值类型

27.exec()

执行字符串或complie方法编译过的字符串,没有返回值

>>> exec("a=1 2 3 4")
>>> a
10

>>> exec('''sum = 0
... for i in range(101):
...   sum =i
... print(sum)
... ''')
5050

Python有4种数值类型:整数、长整数、浮点数和复数。所有数值类型都是不可变类型。

28.isinstance()

判断对象是否是某个类的实例

>>> isinstance('a',str)    #判断a是否是字符类的对象
True
>>> isinstance('a',int)
False
>>> isinstance(11,int)
True
>>> isinstance({1:'a'},dict)
True
>>> isinstance({1,2},dict)
False
>>> isinstance({1,2},set)
True
>>> isinstance((1,2),(str,int,list))  #判断对象是否在元祖中的一个类创建返回True,否则返回False
False
>>> isinstance((1,2),(str,int,list,tuple))
True

python不支持自增自减操作符 ,--, i,其实是 ( i)的意思

29.ord()

ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常

>>> ord('2')   #长度只能为一个字符串
50
>>> ord('a')
97
>>> ord('A')
65
>>> ord('中')  #返回对应的unicode值
20013
>>> ord('国')
22269
>>> ord(' ')  #返回ascii数值
43

运算符与表达式:基本上与其它语言相类似,只是有以下几点不同:

30.sum()

对系列进行求和计算,只能是列表或元祖

>>> sum([1,2,3,4])   #求有序列的和,只能是数字类型
10
>>> sum([1,2,3,4],5)  #对有序列求和后相加的数字
15

x*y:乘法。2 * 3得到6。'la' * 3得到'lalala'。
x**y:幂运算,返回 x 的 y 次幂。
x/y:x 除以 y,4/3得到1(整数的除法得到整数结果)。4.0/3或4/3.0得到1.3333333333333333。
x//y:取整除。返回商的整数部分。4 // 3.0得到1.0。
除法//:地板除在任何时候都会将小数部分舍为0
-x  改变x的符号位

31.bytearray()

返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256

>>> bytearray()   #没有参数时,初始化数组0个元素
bytearray(b'')
>>> bytearray(12)  #为整数时,返回一个长度为源的初始化数组
bytearray(b'x00x00x00x00x00x00x00x00x00x00x00x00')
>>> bytearray('python','utf-8')  #为字符串时,按指定编码转换为字节序列
bytearray(b'python')
>>> bytearray([1,2,3])  #可迭代时,必须为0-255中的整数,字节序列
bytearray(b'x01x02x03')

4.3 字符串
字符串:单引号(‘)和双引号(")的作用相同,只能创建单行字符串。转义符是()。

32.filter()

用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的迭代器

语法:filter(function,iterable)     function:判断函数,iterable:可迭代对象

>>> def is_odd(x):
...   return x % 2 == 1    #创建一个过滤奇数的函数
... 
>>> newlist = filter(is_odd,[1,2,3,4,5,6,7,8,9])  #使用filter过滤以is_odd函数为判断依据的迭代器
>>> print(newlist)
<filter object at 0x7f544ab79908>
>>> next(newlist)  #使用next打印迭代器的下一个值
1
>>> next(newlist)
3
>>> next(newlist)
5
>>> next(newlist)
7
>>> next(newlist)
9

三引号(如:'''或者""")之间的一切都是字符串的内容。

33.issubclass()

用于判断参数 class 是否是类型参数 classinfo 的子类

class A(object):
    pass

class B(A):
    pass

print(issubclass(B,A))  #判断B是否是A的派生类,是返回True,否则返回False

自然字符串:在字符串前加R(或r)指示某些不需要如转义符那样的特别处理的字符串,如:print R“Hellon World”,将直接输出“Hellon World”而不会出现换行的情况。

34.pow()

返回x的y次方,如果z存在则再对结果取模(pow(x,y)%z)

>>> pow(6,2)    #6的2次方
36
>>> pow(6,2,5)  #先预算6的2次方,在对结果取5的模
1
>>> pow(8,2)
64
>>> pow(8,2,5)
4
#math模块的pow()方法对比
>>> import math
>>> math.pow(6,2)    #math模块会把参数转换成float计算
36.0
>>> math.pow(6,2,5)   #math模块中没有取模方法参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3

复制代码 代码如下:

35.super()

调用父类的方法

class A(object):
    def __init__(self):
        self.name = 'python'
    def foo(self):
        print('class,A')

class B(A):
    super(A)  #调用父类的方法和属性
    def foo_b(self):
        print('class',self.name)

#print(issubclass(B,A))
bb = B()
bb.foo()
bb.foo_b()

#output
class,A
class python

a="hello world"
b=a[0,5]            # b="hello"
c=a " I love you"   # c="hello world I love you"
s="The value of x is " str(x)

36.float()

用于将整数和字符串转换成浮点数

>>> float(2)
2.0
>>> float('2')
2.0
>>> float(-23)
-23.0

获得子串: s[i:j],返回 s 从i到j(不包括j)之间的子串。若i省略则i=0,若j省略则j=len(s)-1

37.iter()

用来生成迭代器

>>> new1 = iter(('a','b','c','e','g'))
>>> new1
<tuple_iterator object at 0x7f544ab7b5f8>
>>> next(new1)
'a'
>>> next(new1)
'b'

str() repr() 函数或者向后的引号(`)可以将其他类型的数据转换为字符串。

38.print()

打印输出

语法:print(*objects,sep=' ',end='n',file=sys.stdout)

  • objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
  • sep -- 用来间隔多个对象,默认值是一个空格。
  • end -- 用来设定以什么结尾。默认值是换行符 n,我们可以换成其他字符串。
  • file -- 要写入的文件对象。

    print('hello world') hello world print('hello world',123) #多对象打印 hello world 123 print('hello world',123,sep=' ') #多对象打印连接符 hello world 123 print('hello world',123,sep=' ',end='t') #结尾符设置 hello world 123 >>> print('hello world',123,sep=' ',end='') hello world 123>>>

Unicode字符串:在字符串前加U(或u)。如 a=u'hello',每个字符用16位来表示 "hello" 'world'会被自动连接为一个字符串"helloworld" ,"s1" u"s2"就会产生u"s1s2"

39.tuple()

将列表转换成元组

>>> tuple([1,2,3,4,5])   #列表转元组
(1, 2, 3, 4, 5)
>>> tuple({1,2,3,4,5})   #集合转元组
(1, 2, 3, 4, 5)
>>> tuple({1:'a',2:'b',3:'c'})  #字典转元组,只获取自动的key
(1, 2, 3)

字符串、Unicode字符串及tuple是不可变的序列。

40.callable()

检查一个对象是否是可调用的,返回True否则返回False

>>> def func():
...   return 1   2
... 
>>> func()
3
>>> callable(func)   #对象函数可执行返回True
True

4.4 列表和元组(list & tuple)

41.format()

格式化字符串,语法通过{}和:来代替以前的%,不限制参数个数,可以不按顺序传参

In [27]: '{} {}={}'.format(1,2,3)   #格式化按顺序应用参数值
Out[27]: '1 2=3'
In [28]: '{2}-{1}={0}'.format(1,2,3)  #指定顺序应用参数值,0代表第一个元素,1代表第二个元素,以此类推,指定元素位置时要么全部指定,要不都不指定,不能只指定一部分
Out[28]: '3-2=1'
In [29]: '{0} {0}={1}'.format(2,3)  #指定参数可以重复使用
Out[29]: '2 2=3'
In [30]: '{} {}={}'.format(2,3)   #如不指定顺序,format参数不够就会报错
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-30-29f40e412920> in <module>()
----> 1 '{} {}={}'.format(2,3)
IndexError: tuple index out of range

In [31]: l1 = [2,4,8]     
In [32]: '{}*{}={}'.format(*l1)   #使用列表引用参数值
Out[32]: '2*4=8'

In [33]: dct = {'name':'python','age':20}   #定义字典
In [35]: 'welcom to {name},age is {age}'.format(name='qi',age=28) #变量引用
Out[35]: 'welcom to qi,age is 28'

In [36]: 'welcom to {name},age is {age}'.format(**dct) #使用**引用字典参数必须填写key值
Out[36]: 'welcom to python,age is 20'

填充与格式化:
In [53]: "{0: >20}".format("string")   #使用空格填充20宽度右对齐,0代表指定第一个参数值
Out[53]: '              string'

In [54]: "{0:&>20}".format("string")
Out[54]: '&&&&&&&&&&&&&&string'

In [55]: "{0:#>20}".format("string") #使用#号会有个小bug
   ....:     
Out[55]: '##############string'

In [60]: '{0: <20}'.format("string")  #向左对齐填充 
Out[60]: 'string              '

In [61]: '{0: ^20}'.format("string")  #剧中对齐填充 
Out[61]: '       string       '

精度与进制:
>>> '{0:.3f}'.format(10/3)    #小数位进度格式化
'3.333'
>>> '{0:b}'.format(8)    #格式化二进制
'1000'
>>> '{0:o}'.format(9)  #格式化八进制
'11'
>>> '{0:x}'.format(26) #格式化十六进制
'1a'
>>> '{0:,}'.format(123456789)  #千分位格式化
'123,456,789'

使用索引:
>>> l2 = ['AA',{'bb':'cc'},('d','e')]   #列表索引引用
>>> 'outing:{0[0]}'.format(l2)  
'outing:AA'
>>> 'outing:{0[0]},{0[1]}'.format(l2)  #将列表当成一个元素,在其中索引值
"outing:AA,{'bb': 'cc'}"

列表和元组是任意对象的序列,支持的常用操作:

42.len()

返回对象(字符、列表、元组等)长度或项目个数

>>> len('python')
6
>>> len('123')
3
>>> len([1,2,3,4])
4
>>> len((1,2,3,4))
4
>>> len({1:'a',2:'b',3:'c'})
3
>>> len({1,2,3,4})
4

复制代码 代码如下:

43.property()

在新式类中返回属性值

len()
append()
insert(index,aMember)
list[index]=aNewMember

44.type()

返回对象的类型

>>> type('123')
<class 'str'>
>>> type(12)
<class 'int'>
>>> type(12.2)
<class 'float'>
>>> type([])
<class 'list'>
>>> type(())
<class 'tuple'>
>>> type({})
<class 'dict'>
>>> type({1,2,3})
<class 'set'>

一个元素的元组:a=(12,)  #注意一定要个额外的逗号!
对于tuple中的元素,不可以修改,也不可以添加
列表是可变的序列,允许插入,删除,替换元素等操作

45.chr()

返回一个数字在ASCII编码中对应的字符,取值范围256个

>>> chr(1)
'x01'
>>> chr(11)
'x0b'
>>> chr(255)
'ÿ'
>>> chr(256)
'Ā'
>>> chr(257)
'ā'
>>> chr(0x31)
'1'
>>> chr(0x3)
'x03'
>>> chr(0x11)
'x11'

可变序列支持的操作:

46.frozenset()

返回一个冻结的集合,冻结后集合不能再添加或删除任何元素

>>> set1 = frozenset([1,2,3,4])  #列表返回一个不可变集合
>>> set1
frozenset({1, 2, 3, 4})
>>> frozenset((5,6,7))  #元祖返回一个不可变集合
frozenset({5, 6, 7})
>>> a
{1: 'a', 2: 'b', 3: 'c'}
>>> frozenset(a)     #字典返回一个不可变集合
frozenset({1, 2, 3})
>>> frozenset({3,4,5})  #集合返回一个不可变集合
frozenset({3, 4, 5})

复制代码 代码如下:

47.list()

将字符串或元祖转换为列表

>>> l1 = list('python')   #字符串转列表
>>> type(l1)
<class 'list'>
>>> l1
['p', 'y', 't', 'h', 'o', 'n']
>>> list((1,2,3,4,5))  #元祖转列表
[1, 2, 3, 4, 5]
>>> dic1 = {1:'a',2:'b',3:'c'}
>>> list(dic1)   #字典转列表
[1, 2, 3]
>>> list({1,2,3,4})  #集合转列表
[1, 2, 3, 4]
>>> list()   #返回空列表
[]

s[i]=v
s[i:j]=t    # t要是个序列
del s[i]
del s[i:j]

48.range()

创建一个整数列表

>>> l1 = range(5)
>>> l1
range(0, 5)
>>> for i in l1:    #循环取序列
...   print(i)
... 
0
1
2
3
4
>>> for i in range(1,4):print(i)  #指定起始和结束位置
... 
1
2
3
>>> for i in range(1,10,3):print(i) #指定起始和结束位置和步长
... 
1
4
7
>>> for i in range(0,-10,-4):print(i) #负数以补偿循环
... 
0
-4
-8
>>> for i in range(len('python')):print('python'[i]) #字符串循环打印
... 
p
y
t
h
o
n

4.5 字典

49.vars()

返回当前模块中的所有变量

>>> class runoob:
...   a = 1
... 
>>> print(vars(runoob))
{'__dict__': <attribute '__dict__' of 'runoob' objects>, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'runoob' objects>, 'a': 1}
>>> aa = runoob()
>>> aa
<__main__.runoob object at 0x7f98f1b3c0d0>
>>> print(vars(aa))
{}

字典就是一个关联数组(或称为哈希表),是一个通过关键字索引的对象集合。

50.classmethod()

返回一个类方法,具体实例请看python3之面向对象类定义

使用{}来创建一个字典

51.getattr()

返回一个对象属性值,也就是函数内存地址

class test(object):
    i = 'hello'
    def show(self):
        print('output:',self.i)

obj1 = test()  #实例化对象
ss = getattr(obj1,'show')  #返回一个对象的方法内存地址
ss()   #执行对象方法


#output
output: hello

 

复制代码 代码如下:

52.set()

创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

>>> s1 = set('pythonpython')
>>> s1 = set('pythonpython')  #重复的被删除
>>> s1
{'h', 'n', 'o', 'p', 't', 'y'}
>>> type(s1)
<class 'set'>

>>> s2 = set('pyqi')
>>> s2
{'p', 'y', 'i', 'q'}
>>> s1 & s2  #交集
{'p', 'y'}
>>> s1 | s2  #并集
{'p', 'q', 't', 'i', 'h', 'y', 'n', 'o'}
>>> s1 - s2   #差集i
{'h', 't', 'n', 'o'}

a={
    "username":"loo"
    "home":"/home/loo"
    "uid":500
  }
u=a["username"]            #访问
a["username"]="lu"         #修改
a["shell"]="/usr/bin/tcsh" #添加
del a["shell"]             #删除
len(a)                     #元素个数
a[("loo",123)]="abc"

53.locals()

以字典类型返回当前位置的全部局部变量

>>> def funct(*args):   #两个局部变量
...   a = 22 
...   print(locals())
... 
>>> funct(33,44)    #返回所有局部变量的健值
{'a': 22, 'args': (33, 44)}

字典的key是不能修改的对象(比如数字和tuple)。

54.repr()

将对象转化为供解释器读取的形式

>>> aa = repr([1,2,3])
>>> type(aa)   #将对象转换为字符
<class 'str'>
>>> repr({'a':'A','b':'B'})
"{'a': 'A', 'b': 'B'}"

**五、循环

55.zip()

用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表

如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表

>>> aa = (zip([1,2,3],['a','b','c']))
>>> aa
<zip object at 0x7f98f1893680>
>>> next(aa)
(1, 'a')
>>> next(aa)
(2, 'b')
>>> next(aa)
(3, 'c')
>>> bb = zip([1,2,3],['a','b','c','d'],['A','B','C','D','E'])
>>> bb
<zip object at 0x7f98f18936c8>
>>> next(bb)
(1, 'a', 'A')
>>> next(bb)
(2, 'b', 'B')
>>> next(bb)
(3, 'c', 'C')

**

56.compile()

将一个字符串编译为字节代码

>>> str = 'for i in range(10):print(i)'
>>> c = compile(str,'','exec')
>>> c
<code object <module> at 0x7f98f1b774b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = '3*5 3'
>>> a = compile(str,'','eval')
>>> eval(a)
18

复制代码 代码如下:

57.globals()

以字典类型返回当前位置的全部全局变量

>>> a = 'python'
>>> print(globals())   #返回一个全局变量的字典,包括导入的变量
{'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins' (built-in)>, 'a': 'python', '__name__': '__main__', '__doc__': None, '__package__': None, '__spec__': None}

for i in range(1,5):
    print "2 to the %d power is %d" % (i,2**i)

58.map()

将函数调用映射到每个序列的对应元素上并返回一个含有所有返回值的列表

>>> def out(x,y):
...   return (x,y)
... 
>>> l1 =map(out,[1,2,3,4,5],['a','b','c','d','e'])  #映射序列,返回函数的值
>>> print(list(l1))
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]

>>> def foo(x,y):
...   return x*y
... 
>>> print(list(map(foo,[2,3,4],[5,6,7])))
[10, 18, 28]

内建函数range([i,]j[,stride])建立一个列表,参数i和参数stride是可选的,默认分别为0和1。

59.reversed()

返回一个反转的迭代器

>>> print(list(reversed(range(10))))  #range反转
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> print(list(reversed(['a','c','f'])))
['f', 'c', 'a']
>>> print(list(reversed(('java','c  ','python'))))
['python', 'c  ', 'java']
>>> print(list(reversed('python')))
['n', 'o', 'h', 't', 'y', 'p']

复制代码 代码如下:

60.__import__()

用于动态加载类和函数

a=range(5,1,-1)   # a=[5,4,3,2]
s="hello world"
for c in s:       # 打印每个字符  
    print c

61.complex() 

返回一个复数

>>> complex(1,2)
(1 2j)
>>> complex('2')
(2 0j)
>>> complex('2','3')    #为字符串时只能指定一位
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: complex() can't take second arg if first is a string
>>> complex('2 3j') 
(2 3j)

range()函数在内存中建立一个列表,当需要一个很大的列表时候,这个占内存且耗时间,为了克服这个缺点,python提供了xrange()。xrange()函数只在需要的时候才临时计算提供值,大大节省了内存。

62.hasattr()

用于判断对象是否包含对应的属性

>>> print(hasattr(list,'append'))
True
>>> print(hasattr(tuple,'append'))
False
>>> print(hasattr(tuple,'index'))
True
>>> print(hasattr(dict,'keys'))
True
>>> print(hasattr(dict,'values'))
True

六、函数

63.max()

返回给定参数的最大值

>>> max([2,44,55,88])
88
>>> max((3,48))
48
>>> max({1:48,2:23})
2

def say(message, times = 1):  # time 的默认参数值是 1
    print message * times   
    return time               # 无返回值的函数可省掉 return,等同于return None
只有在形参表末尾的那些参数可以有默认参数值,即你不能在声明函数形参的时候,先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如,def func(a, b=5)是有效的,

64.round()

返回浮点数x的四舍五入值

>>> print(round(1.345))
1
>>> print(round(1.345,3))   #3为小数点后位数
1.345
>>> print(round(1.345,2))
1.34
>>> print(round(1.345,1))
1.3
>>> print(round(1.545,1))
1.5
>>> print(round(1.545,2))
1.54

但是def func(a=5, b)是无效的。

65.delattr()

删除对象的属性

global a  # 获得全局变量a

66.hash()

获取一个对象(字符串或者数值等)的哈希值

>>> hash('python')
-7183818677546017823
>>> hash(1)
1
>>> hash(36)
36
>>> hash([1,2,3])   #列表不能取哈希值
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash(str([1,2,3]))
-1281906435344341319
>>> hash(str({1:'a'}))
-6473938891374685725
>>> hash(str({'1':'1'}))
-5747816388481399936

用户自定义函数:

67.memoryview()

返回字节对象的内存地址

>>> a = bytes([1,2,3])   #定义一个字节对象
>>> a
b'x01x02x03'
>>> memoryview(a)
<memory at 0x7f7cd1bbcb88>
>>> b = memoryview(a)    #返回字节对象的内存地址
>>> b[0]
1
>>> b[1]
2
>>> b[1:4]    #切片取的是一个迭代器
<memory at 0x7f7cd1bbcb88>
>>> b[1:3].tobytes()
b'x02x03'
>>> for i in b:print(i)   #迭代取数值
... 
1
2
3

后续更新实例。。。。

复制代码 代码如下:

def foo(x,y):
    print '%s %s is %s' % (str(x),str(y),str(x y))
bar=foo
bar(3,4)
d={}
d['callback']=foo
d['callback'](3,4)     # 调用foo

用户自定义函数有如下属性:

f.__module__                        #函数所在的模块名
f.__doc__ 或者 f.func_doc       #文档字符串
f.__name__ 或者 f.func_name #函数名
f.__dict__ 或者 f.func_dict      #支持任意函数属性的函数名字空间
f.func_code                          #编译后产生的字节码
f.func_defaults                     #包含所有默认参数的元组
f.func_globals                      #函数所在的模块的全局名称空间的字典
f.func_closure                     #None or a tuple of cells that contain bindings for the function's free variables.

七、类

复制代码 代码如下:

class Stack(object):
    def __init__(self):
        self.stack=[]
    def push(self,object):
        self.stack.append(object)
    def pop(self):
        return self.stack.pop()
    def length(self):
        return len(self.stack)
s=Stack()
s.push("Dave")
s.push(42)
s.push([3,4,5])
print s.length()
print s.pop()
y=s.pop()
print y
del s

类方法的定义:

复制代码 代码如下:

# 静态方法:
class AClass(object):
    @staticmethod
    def astatic():
            print 'a static method'
# 类方法:
class ABase(object):
    @classmethod
    def aclassmethod(cls):

isinstance(s,C) 用于测试s是否是C或是C的子类的实例
issubclass(A,B) 用于测试A是否是B的子类

八、异常

用try和except语句来捕获异常:

复制代码 代码如下:

try:
    f=open("file.txt","r")
except IOError,e:
    print e
except TypeError,e:
    print e
...
try:
    do something
except:
    print 'An error occurred'

如果有IOError异常,就将错误原因放置在对象e中,然后运行except代码块,如果发生其他类型的异常就将控制权转到处理该异常的except的代码块,如果没找到该代码块,程序将终止运行,若没有发生异常,except代
码会被忽略掉。

九、模块

import 模块名
import 模块名 as 别名
from 模块 import 对象(函数)
from 模块 import *
内建函数dir()可以列出一个模块中的所有可访问的内容
可以被import导入的模块:
1.使用python写的程序(.py程序)
2.C或C 扩展(已编译的共享库或DLL)
3.包(包含多个模块)
4.内建模块(使用C写的并已链接到python解释器内)

十、引用与副本(引用计数)

python中的一切数据都是对象。
对于可变对象,改变一个引用就等于改变了该对象的所有的引用:

复制代码 代码如下:

a=[1,2,3,4]
b=a
b[2]=100
print a   # a=[1,2,100,4]

为了避免这种情况,你需要创建一个可变对象的副本,然后对该副本进行操作。

两种创建可变对象的副本:

(1)浅拷贝(shallow copy):创建一个新对象,但它包含的子元素仍然是原来对象子元素的引用:

复制代码 代码如下:

b=[1,2,[3,4]]
a=b[:]
a.append(100)
print b       # b=[1,2,[3,4]] b没有变
a[0]=100
print b       # b=[1,2,[3,4]] b没有变
a[2][0]=100
print b       # b=[1,2,[100,4]] b被改变了

(2)深拷贝(deep copy)

复制代码 代码如下:

import copy
b=[1,2,[3,4]]
a=copy.deepcopy(b)

__del__()在对象销毁时调用。 del x 只是减少对象x的引用计数,并不调用这个函数。

十一、类型转换

复制代码 代码如下:

int(x[,base])   #转换为int
long(x[,base])
float(x)
tuple(x)
list(x)
chr(x)        #转换为字符
unichr(x)     #转换为Unicode字符
ord(x)        #字符转换为整数值  
str(x)
a=[1,2,3,4]
s=repr(a)   # s='[1,2,3,4]'  也可以使用 s='a'
b=eval(s)   # b=[1,2,3,4]    再转换成一个列表
eval('3 4')
f=open("foo")
a=repr(f)  # a="<open file 'foo',mode 'r' at dc030>"

十二、其他

文档字符串DocStrings: 如果一个模块、类、函数体的第一个语句是未命名的字符串,改字符串就自动成为该对象的文档字符串 说白了就是类似于JavaDoc的东西。

文档字符串的惯例是一个多行字符串,它的首行以大写字母开始,句号结尾。第二行是空行,从第三行开始是详细的描述。可以使用__doc__(注意双下划线)调用函数的文档字符串属性(属于函数的名称)。Python把每一样东西都作为对象,包括这个函数。

Python中的help(),它所做的只是抓取函数的__doc__属性,然后整洁地展示给你。

自动化工具也可以以同样的方式从你的程序中提取文档。随Python发行版附带的pydoc命令,与help()类似地使用DocStrings。

复制代码 代码如下:

def printMax(x, y):
    '''Prints the maximum of two numbers.''' # 这里是文档字符串
    print "DocStrings"                       # 这里是函数体命令行参数
>>>print printMax.__doc__
Prints the maximum of two numbers.

id(a)可以查看该对象的标识(当前的实现是该对象在内存中的位置)

复制代码 代码如下:

if type(a) is type(b):
    print 'a and b have the same type'
if type(a) is types.ListType
    print 'Is a list'

isinstance(s,C) 用于测试s是否是C或是C的子类的实例

复制代码 代码如下:

import types
isinstance(3,types.IntType)  #返回True

x==y 比较x和y的值是否相等
x is y 和x is not y 比较x和y在内存中是否指向同一个对象

复制代码 代码如下: 1 1 2 print 'hello world' hello world x = 1 y = 2 x y 3 Python是强类型语言,无法根据上下文自动解析转换成合...

本文由新葡萄京娱乐场8522发布于计算机编程,转载请注明出处:文本输入,5种数据类型

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。