标签：
一些例子：后期慢慢接触到再补充
# help() 详细查看某个类有那些方法或者方法的具体使用
>>> help(str)
>>> help(str.strip)
# dir() 快速查看某个类有那些方法或者方法的具体使用
>>> dir(str)
>>> dir(str.strip)
# int() 实例化数字类型,或将其他类型转换为数字类型,或各种进制转换为十进制
(1)实例化数字类型 >>> i = int(23) >>> print(type(i),i) <class ‘int‘> 23 (2)将数字字符串转换为数字类型,只能时数字字符串才能转为数字类型,否则报错 >>> s = "123" >>> type(s) <class ‘str‘> >>> i = int(s) >>> print(type(i),i) <class ‘int‘> 123 (3)将二进制转换为十进制 >>> print(int(‘11‘,base=2)) 3
# float() 实例化浮点类型,或将数字字符串转换为浮点型,仅限于数字字符串
(1) 实例化浮点类型 >>> f = float(12) >>> print(type(f),f) <class ‘float‘> 12.0 (2) 将数字字符串转换为浮点类型 >>> s = "12" >>> type(s) <class ‘str‘> >>> i = float(s) >>> print(type(i),i) <class ‘float‘> 12.0
# str() 实例化字符串类型,或将其他类型转换为字符串类型
(1) 实例化字符串类型 >>> s = "python" >>> print(type(s)) <class ‘str‘> (2) 将其他类型转换为字符串类型了 >>> s = 88888 >>> type(s) <class ‘int‘> >>> i = str(s) >>> print(type(i),i) <class ‘str‘> 88888 >>> l = [1,2,3,4,5] >>> a = str(l) >>> print(type(a),a) <class ‘str‘> [1, 2, 3, 4, 5] 注意：列表格式或字典格式的字符串类型转换为列表或者字典需要使用json模块
# list() 将其他类型转为列表类型
(1) 实例化列表类型 >>> l = list(["redhat","centos","ubuntu"]) >>> print(type(l),l) <class ‘list‘> [‘redhat‘, ‘centos‘, ‘ubuntu‘] (2) 将其他类型转换为列表 >>> s = "python" >>> l = list(s) >>> print(type(l),l) <class ‘list‘> [‘p‘, ‘y‘, ‘t‘, ‘h‘, ‘o‘, ‘n‘] >>> t = ("python","I","like") >>> l1 = list(t) >>> print(type(l1),l1) <class ‘list‘> [‘python‘, ‘I‘, ‘like‘]
# tuple() 实例化元组类型,或将其他类型转换为元组类型
(1) 实例化元组类型 >>> t1 = tuple(("redhat","centos","ubuntu","opensuse")) >>> print(type(t1),t1) <class ‘tuple‘> (‘redhat‘, ‘centos‘, ‘ubuntu‘, ‘opensuse‘) (2) 将其他类型转换为元组类型 >>> l = [11,22,33,44,55] >>> type(l) <class ‘list‘> >>> t = tuple(l) >>> print(type(t),t) <class ‘tuple‘> (11, 22, 33, 44, 55)
# dict() 实例化字典,或将元组列表转换为字典类型仅限元组形式列表类型
(1) 实例化字典类型 >>> d1 = dict({"os":"ubuntu","version":15.10,"kernel":"4.2.0-16"}) >>> print((d1),d1) <class ‘dict‘> {‘version‘: 15.1, ‘os‘: ‘ubuntu‘, ‘kernel‘: ‘4.2.0-16‘} (2) 将元组形式的列表转换为字典 >>> l3 = [(‘a‘,1),(‘b‘,11),(‘c‘,45)] >>> d2 = dict(l3) >>> print(type(d2),d2) <class ‘dict‘> {‘b‘: 11, ‘c‘: 45, ‘a‘: 1} 注意：zip()这个内置方法可以将两个列表生成元组形式列表类型
# set() 实例化可变集合类型,或其他类型转换成集合类型
(1) 实例化集合类型 >>> s = set({"fedora","geentoo","debian","centos"}) >>> print(type(s),s) <class ‘set‘> {‘fedora‘, ‘centos‘, ‘debian‘, ‘geentoo‘} (2) 将其他类型转换成集合set类型 >>> l = ["centos","centos","redhat","ubuntu","suse","ubuntu"] >>> s = set(l) >>> print(type(s),s) <class ‘set‘> {‘ubuntu‘, ‘centos‘, ‘redhat‘, ‘suse‘} >>> d = {"kernel":"Linux","os":"ubuntu","version":"15.10"} >>> s = set(d.keys()) >>> print(type(s),s) <class ‘set‘> {‘kernel‘, ‘version‘, ‘os‘}
# frozenset() 实例化不可变集合,或类型转换成不可变集合类型
(1) 实例化不可变集合 >>> fs = frozenset({"redhat","centos","fedora","debian","ubuntu"}) >>> print(type(fs),fs) <class ‘frozenset‘> frozenset({‘fedora‘, ‘ubuntu‘, ‘centos‘, ‘debian‘, ‘redhat‘}) (2) 类型转换成不可变集合 >>> l = [1,2,3,4,4,5,5] >>> fs1 = frozenset(l) >>> print(type(fs1),fs1) <class ‘frozenset‘> frozenset({1, 2, 3, 4, 5})
# bool() 0,"",None,[],(),{}都为假,其余都为真,是int的子类
>>> bool(0) False >>> bool("abc") True >>> bool("") False >>> bool([]) False >>> bool() False >>> issubclass(bool, int) True
# bytes() 将字符串类型转换成字节byte类型,在计算机底层都是以二进制存储数据的
# 1bytes = 8bit,一个汉字utf8是用3个字节存储,一个汉字gbk是用2个字节存储,一个字母数字是1字节
# bytes(要转换的字符串,按照什么编码)
(1) 将字符串转换为字节类型 >>> s = "大神" >>> p = bytes(s,encoding="utf-8") >>> print(type(p),p) <class ‘bytes‘> b‘\xe8\x9f\x92\xe8\x9b\x87‘ (2) 将字节类型重新转换为字符串 >>> new_s = str(p,encoding="utf-8") >>> print(type(new_s),new_s) <class ‘str‘> 大神 注意: 在文件对象处理的时候注意打开的模式如果以wb模式打开,则写入的数据需要转换成bytes()写入
# bytearray() 和bytes()是一样的,只是返回一个byte列表
# bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0,255]
>>> a = bytearray("大神",encoding="utf-8") >>> print(type(a),a) <class ‘bytearray‘> bytearray(b‘\xe8\x9f\x92\xe8\x9b\x87‘) >>> a[0] 232 >>> a[1] 159 >>> a[2] 146 >>> a[4] 155 >>> a[5] 135
# open() 是打开一个文件对象,用于对文件的操作处理
>>> with open("/etc/passwd","r") as f: ... for line in f: ... print(line) 注意: 具体的操作,请查看文件对象这边博客
# type() 查看某个实例属于哪个类型
>>> s = "python"
>>> l = [1,2,3,4]
>>> t = ("linux","python")
>>> d = {"name":"linux","age":12}
>>> print(type(s),type(l),type(t),type(d))
<class ‘str‘> <class ‘list‘> <class ‘tuple‘> <class ‘dict‘>
# id() 查看对象在内存中的地址
>>> s = "python" >>> id(s) 139639742647240 >>> l = [1,2,3,4] >>> id(l) 139639704025736
# len() 查看实例中的长度,说白点就是元素个数
# python2.x是以字节计算,python3.x是以字符计算
>>> s = "python" >>> len(s) 6 >>> s = "大神" >>> len(s) 2 python3.x如果需要以字节计算,要先转换成bytes() >>> b = bytes(s,encoding="utf-8") >>> len(b) 6
# input() 输入,默认输入的格式为字符串,输入的数字也是字符串,需要int()转换,python2.x是用ray_input()方法
>>> data = input("please say something:") please say something:today is good day >>> print(data) today is good day >>> data1 = input("please say something:") please say something:123 >>> print(type(data1),data1) <class ‘str‘> 123 # print() 输出,格式化输出 >>> name = "python" >>> print("I love %s" % name) I love python 注意: 具体查看格式化输出相关博客
# all() 接收一个迭代对象
# 0,"",None,[],(),{}都为假,all是全部为真则为真,有一个假则为假
>>> s = ["python","php","java"] >>> print(all(s)) True >>> a = ["","python","php"] >>> print(all(a)) False
# any() 只要有一个为真则为真,全为假则为假
>>> a = ["","python","php"] >>> print(any(a)) True >>> s = ["",0,(),[],{},None] >>> print(any(s))
# max(),min(),sum() 一般是数字系列中的最大,最小,求和
>>> r = max([11,22,33]) >>> print(r) 33 >>> r1 = min([11,22,33]) >>> print(r1) 11 >>> r2 = sum([11,22,33]) >>> print(r2) 65
# abs() 求绝对值
>>> print(abs(-123)) 123
# pow() 求几次方和**是一样的
>>> print(pow(2,10)) 1024 >>> 2**10 1024
# round() 四舍五入
>>> print(round(18.8)) 19 >>> print(round(18.4)) 18
# divmod() 除法得余数,在分页功能中会用到
>>> print(divmod(78,10)) (7, 8) >>> print(divmod(45,10)) (4, 5)
# chr() ascii表的对应关系,十进制数字转为字符
# ord() ascii表的对应关系,将ascii字符转为数字
>>> r = chr(65) >>> print(r) >>> n = ord("a") >>> print(n) 注意:利用这两个函数和random可以实现随机数字字母验证码,最后有代码
# bin() 十进制转二进制
# oct() 十进制转八进制
# hex() 十进制转十六进制
>>> print(bin(5)) >>> print(oct(9)) >>> print(hex(15))
# enumerate() 枚举类型,实现循环的时候打印出行号,默认是0开始,也可以设置1开始
>>> li = ["redhat","centos",‘fedodra‘] >>> for index,data in enumerate(li): ... print(index,data) ... 0 redhat 1 centos 2 fedodra >>> li = ["redhat","centos",‘fedodra‘] >>> for index,data in enumerate(li,1): ... print(index,data) ... 1 redhat 2 centos 3 fedodra
# sorted() 排序,不能数字和字母在一起排序和list.sorted()是一样的,python2.x是可以混合排序的
>>> l1 = [1,5,2,55,33] >>> a = sorted(l1) >>> print(a) [1, 2, 5, 33, 55] >>> l2 = [1,5,2,55,33,66] >>> l2.sort() >>> print(l2) [1, 2, 5, 33, 55, 66]
# reversed() 逆序和list.reverse()是一样的
>>> l3 = [33,22,55,11] >>> a = reversed(l3) >>> print(list(a)) >>> l4 = [33,22,55,11,44] >>> l4.reverse() >>> print(l4) [44, 11, 55, 22, 33]
# slice() 和字符串列表的切片的功能是一样的
>>> s = "python" >>> s[0:4] ‘pyth‘ >>> s[0:4:2] ‘pt‘ >>> b = slice(0,4,2) >>> print(b) slice(0, 4, 2) >>> s[b] ‘pt‘
# zip() 取一个或多个序列为参数,把序列中的并排元素配成元组,返回元组形式的列表类型,当元素长度不同时以最短序列的长度为准
>>> l1 = [‘烧饼‘,11,22,33] >>> l2 = [‘is‘,11,22,33] >>> l3 = [‘sb‘,11,22,33] >>> r = zip(l1,l2,l3) >>> print(list(r)) [(‘烧饼‘, ‘is‘, ‘sb‘), (11, 11, 11), (22, 22, 22), (33, 33, 33)] >>> temp = list(r)[0] >>> ret = ‘ ‘.join(temp) >>> print(ret) 烧饼 is sb # 两个列表合成一个字典 >>> keys = [1,2,3,4,5,6,7] >>> vaules = [‘Sun‘,‘Mon‘,‘Tue‘,‘Wed‘,‘Thu‘,‘Fri‘,‘Sat‘] >>> D = {} >>> for (k,v) in zip(keys,values): ... D[k] = v ... >>> D {1: ‘Sun‘, 2: ‘Mon‘, 3: ‘Tue‘, 4: ‘Wed‘, 5: ‘Thu‘, 6: ‘Fri‘, 7: ‘Sat‘}
# compile() 将代码编译成python代码
# eval() 只能执行表达式,并且返回结果
# exec() 执行python代码或者先编译成python代码再执行,接收：代码或者字符串,没有返回结果
>>> s = "print(123)" >>> r = compile(s,"<string>","exec") >>> exec(r) 123
# exec和eval的区别 >>> exec("7+8+9") >>> ret = eval("7+8+9") >>> print(ret) 24
# complex() 创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
参数real: int, long, float或字符串；
参数imag: int, long, float。
>>> complex(1, 2) (1 + 2j) >>> complex(1) #数字 (1 + 0j) >>> complex("1") #当做字符串处理 (1 + 0j) >>> complex("1+2j") (1 + 2j) #注意：这个地方在“+”号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
# globals() 显示所有的全局变量
# locals() 显示所有的局部变量
>>> NAME = ‘tomcat‘ >>> def show(): ... a = 123 ... b = 456 ... print(locals()) ... print(globals()) ... >>> show()
# vars() 本函数是实现返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。如果有参数输入，就只打印这个参数相应的属性和属性值。
>>> class Foo: ... a = 1 >>> print(vars(Foo)) >>> foo = Foo() >>> print(vars(foo))
# callable() 判断是否可以被调用
>>> def f1(): ... pass ... >>> print(callable(f1)) >>> f2 = 123 >>> print(callable(f2))
# range() 在python2中有xrange和range，其中range会一次在内存中开辟出了所需的所有资源，而xrange则是在for循环中循环一次则开辟一次所需的内存，而在Python3中没有xrange，只有range ，但是python3的range代表的就是xrange。range用来指定范围，生成指定的数字。
>>> for i in range(4): ... print(i) ... 0 1 2 3 >>> for i in range(1,4,2): ... print(i) ... 1 3
# format() 格式化输出的,和百分号是同样的功能
>>> print("1 am {},age {}".format(‘jason‘,18)) # 用{}当作占位符 >>> print("1 am {},age {}".format(*[‘jason‘,18])) # 用*传递一个列表进去 >>> print("1 am {0},age {1}，score{1}".format(‘jason‘,18)) # 1 am jason,age 18，score18 用 0，1等数字来应用 注意: 具体查看格式化输出相关
# hash() 一般用在字典中的Key是进行hash计算后,值存入内存,hash值
>>> dic = {‘name‘:‘SB‘}
>>> print(hash(dic[‘name‘]))
# filter() filter(函数,可迭代对象),fileter内部,循环第二个参数,将每一个元素执行第一个函数
# 如果函数返回值True,表示元素合法,就把元素存入结果ret中
>>> def f2(a): ... if a>22: ... return True >>> li = [11,22,33,44,55] >>> ret = filter(f2,li) >>> print(list(ret)) 注意: 对于简单的函数用lambda可以实现 >>> result = filter(lambda a: a > 33,li) >>> print(list(result))
# map() map(函数,可迭代的对象),循环第二个参数,将每一个元素执行第一个函数,就把返回值存入结果result中
>>> l1 = [11,22,33,44,55,66] >>> def f3(a): ... return a + 100 >>> result = map(f3,l1) >>> print(list(result)) 注意: 对于简单的函数用lambda可以实现 >>> result = map(lambda a: a + 100,l1) >>> print(list(result))
后期学习到面向对象时补充后面的内置函数
1、通过chr(),ord(),random()生产随机6位验证码
#!/usr/bin/env python # -*- coding:utf-8 -*- import random li = [] for i in range(6): r = random.randrange(0, 4) if r == 2 or r == 4: num = random.randrange(0, 10) li.append(str(num)) else: temp = random.randrange(65,91) c = chr(temp) li.append(c) result = "".join(li) print(result)
标签：
原文地址：http://www.cnblogs.com/xiaozhiqi/p/5743021.html
