5种数据类型,python数据类型

队列平常有一个性状:

python数据类型:连串(字符串,元组,列表,字典),python数据类型

队列日常有一个特征:

一,能够依据目录取值

二,能够切块操作

字符串,元组,列表,字典,都足以当做是种类类型

本人的操作情况:Ubuntu1陆.0四+python二.七

 

1、字符串类型

>按索引获取,索引从0发轫

1 >>> name='ghostwu'
2 >>> name[0]
3 'g'
4 >>> name[1]
5 'h'
6 >>> name[6]
7 'u'
8 >>> 

>切丝操作,第一个冒号的值,表示从哪些索引早先切丝。第二个冒号的值,表示从到哪个索引截止(注意:结果不带有那一个地方)。第二个冒号的值,表示步长

>>> name='My Name Is Ghostwu'
>>> name[0:7]
'My Name'
>>> name[0:7:1]
'My Name'
>>> name[0:7:2]
'M ae'

暗中认可切成片操作为:从左到右。如若幅度为负数,表示从右往左切成块。从后往前数(索引从-1起头), 
type的职能:查看数据类型。

 1 >>> name='My Name Is Ghostwu'
 2 >>> name[-1]
 3 'u'
 4 >>> name[-1:-4]
 5 ''
 6 >>> name[-1:-4:-1]
 7 'uwt'
 8 >>> type(name)
 9 <type 'str'>
10 >>> name[2]
11 ' '
12 >>> name[2:]
13 ' Name Is Ghostwu'
14 >>> name[2:-1]
15 ' Name Is Ghostw'
16 >>> 

字符串别的小本事: 

>len函数,总括长度

>>> str="ghostwu"
>>> len(str)
7

>+号,连接字符串

>>> str="hi "
>>> str2="ghostwu"
>>> str+str2
'hi ghostwu'

 >*号,重复字符串次数,是或不是很轻巧,在php中要用str_repeat只怕循环连接字符串

>>> str="ghostwu"
>>> str*2
'ghostwughostwu'
>>> str
'ghostwu'
>>> 

>in: 判别成分是或不是在连串中

>>> str="ghostwu"
>>> 'g' in str
True
>>> 'x' in str
False
>>> 

>max最大值,min最小值

>>> str="abc123"
>>> max(str)
'c'
>>> min(str)
'1'
>>> 

>cmp(str1,str2) 相比较类别值是不是同样

 1 >>> str="abc"
 2 >>> str2="ab1"
 3 >>> cmp(str,str2)
 4 1
 5 >>> cmp(str2,str)
 6 -1
 7 >>> str2="abc"
 8 >>> cmp(str,str2)
 9 0
10 >>> 

 

2、元组类型

用名称=(item,item,)小括号定义,唯有壹项的时候,要加逗号

字符串的痛点:若是用1个字符串,保存有些人的音信,那么在切除的时候(如人名,年龄,性别)就不太好操作

1 >>> userinfo="ghostwu 20 male"
2 >>> type(userinfo)
3 <type 'str'>
4 >>> userinfo[0:7]
5 'ghostwu'

万1用元组来管理

 1 >>> userinfo=("ghostwu","20","male")
 2 >>> type(userinfo)
 3 <type 'tuple'>
 4 >>> userinfo[0]
 5 'ghostwu'
 6 >>> userinfo[1]
 7 '20'
 8 >>> userinfo[2]
 9 'male'
10 >>> 

看,是否卓殊轻便?唯有壹项时?怎么定义?

>>> userinfo=("ghostwu")
>>> type(userinfo)
<type 'str'>
>>> 

像上面那种概念格局,定义的是2个字符串类型。唯有一项时,供给在后头加个逗号’,’

>>> userinfo=('ghostwu',)
>>> type(userinfo)
<type 'tuple'>
>>> userinfo[0]
'ghostwu'
>>> 

元组定义之后,不得以被退换:

>>> userinfo=("ghostwu",20,"male")
>>> userinfo[0]="zhangsan"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> 

能够行使类似es陆的解构语法,把元组的每一项对应赋值给左侧的变量:

>>> userinfo=('ghostwu',20,'male')
>>> name,age,sex=userinfo
>>> name
'ghostwu'
>>> age
20
>>> sex
'male'

 

三、列表(list)

>中括号定义

>>> list1=[]
>>> type(list1)
<type 'list'>

>>> userinfo=['ghostwu',20,'male']
>>> type(userinfo)
<type 'list'>
>>> userinfo[0]
'ghostwu'
>>> userinfo[1]
20
>>> userinfo[2]
'male'

>列表的切块操作

 1 >>> userinfo=['ghostwu',20,'male']
 2 >>> userinfo[0:1]
 3 ['ghostwu']
 4 >>> userinfo[0:2]
 5 ['ghostwu', 20]
 6 >>> userinfo[::2]
 7 ['ghostwu', 'male']
 8 >>> userinfo[::]
 9 ['ghostwu', 20, 'male']
10 >>> userinfo[::1]
11 ['ghostwu', 20, 'male']

>列表能够被再次赋值,列表项能够被修改,可是不能动态索引格局加码,不然报错(索引超越上限)

 1 >>> userinfo=['ghostwu',20,'male']
 2 >>> len(userinfo)
 3 3
 4 >>> userinfo='zhangsan'
 5 >>> len(userinfo)
 6 8
 7 >>> userinfo=[]
 8 >>> len(userinfo)
 9 0
10 >>> userinfo[0]="ghostwu"
11 Traceback (most recent call last):
12   File "<stdin>", line 1, in <module>
13 IndexError: list assignment index out of range
14 >>> userinfo=["ghostwu",20,"male"]
15 >>> userinfo[0]="zhangsan"
16 >>> userinfo
17 ['zhangsan', 20, 'male']
18 >>> userinfo[3]="china"
19 Traceback (most recent call last):
20   File "<stdin>", line 1, in <module>
21 IndexError: list assignment index out of range
22 >>> 

>列表操作:

取值:切成丝和目录    修改: list[] = x

>>> userinfo=['ghostwu',20,'male']
>>> type(userinfo)
<type 'list'>
>>> userinfo[0]\
... 
'ghostwu'
>>> userinfo[0:2]
['ghostwu', 20]

修改列表的某1项时候,地址未有退换,照旧列表自己

>>> userinfo=["ghostwu",20,"male"]
>>> id(userinfo)
140648386293128
>>> userinfo[0]="hello"
>>> id(userinfo)
140648386293128

元组重新被赋值,也就是再度定义了3个新的元组:

>>> userinfo=("ghostwu",20)
>>> type(userinfo)
<type 'tuple'>
>>> userinfo[0]="hello"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(userinfo)
140648386125696
>>> userinfo=("zhangsan",30)
>>> id(userinfo)
140648386125552

5种数据类型,python数据类型。添加: list.append()

1 >>> userinfo=["ghostwu",20]
2 >>> userinfo
3 ['ghostwu', 20]
4 >>> userinfo.append("male")
5 >>> userinfo
6 ['ghostwu', 20, 'male']
7 >>> userinfo.append("china")
8 >>> userinfo
9 ['ghostwu', 20, 'male', 'china']

 删除: del(list[])   list.remove(list[]) , 
注意:remove删除的是列表中首先次面世的值

 1 >>> userinfo
 2 ['ghostwu', 20, 'male', 'china']
 3 >>> type(userinfo)
 4 <type 'list'>
 5 >>> userinfo.remove(20)
 6 >>> userinfo
 7 ['ghostwu', 'male', 'china']
 8 >>> userinfo.remove("china")
 9 >>> userinfo
10 ['ghostwu', 'male']

>>> userinfo=['ghostwu',20,'ghostwu','male','ghostwu']
>>> userinfo
['ghostwu', 20, 'ghostwu', 'male', 'ghostwu']
>>> userinfo.remove('ghostwu')
>>> userinfo
[20, 'ghostwu', 'male', 'ghostwu']

 1 >>> userinfo
 2 [20, 'ghostwu', 'male', 'ghostwu']
 3 >>> type(userinfo)
 4 <type 'list'>
 5 >>> userinfo.remove('male')
 6 >>> userinfo
 7 [20, 'ghostwu', 'ghostwu']
 8 >>> del( userinfo[1] )
 9 >>> userinfo
10 [20, 'ghostwu']

查找: var in list

1 >>> userinfo
2 [20, 'ghostwu']
3 >>> 20 in userinfo
4 True
5 >>> '20' in userinfo
6 False
7 >>> 'ghostwu' in userinfo
8 True

 

四、字典

她的用法类似于javascript中的json,大括号中用键值对定义,取多少用相应的键

 1 >>> userinfo={'name':'ghostwu', 1 : 20, 'age' : 20, 'sex' : 'male' }
 2 >>> type(userinfo)
 3 <type 'dict'>
 4 >>> userinfo
 5 {1: 20, 'age': 20, 'name': 'ghostwu', 'sex': 'male'}
 6 >>> userinfo['name']
 7 'ghostwu'
 8 >>> userinfo['age']
 9 20
10 >>> userinfo[1]
11 20

字典中的键,能够是字符串,也得以是变量

1 >>> a=10
2 >>> b=20
3 >>> dic={a:'ghostwu','b':'male'}
4 >>> dic
5 {10: 'ghostwu', 'b': 'male'}
6 >>> dic[10]
7 'ghostwu'
8 >>> dic['a']

用接近javascript的for … in语法 遍历字典:

 1 >>> userinfo={'name':'ghostwu','age':20,'sex':'male'}
 2 >>> for key in userinfo:
 3 ...     print key
 4 ... 
 5 age
 6 name
 7 sex
 8 >>> for key in userinfo:
 9 ...     print userinfo[key]
10 ... 
11 20
12 ghostwu
13 male
14 >>> 

为字典增添1项值

1 >>> userinfo
2 {'age': 20, 'name': 'ghostwu', 'sex': 'male'}
3 >>> type(userinfo)
4 <type 'dict'>
5 >>> userinfo['email']='[email protected]'
6 >>> userinfo
7 {'email': '[email protected]', 'age': 20, 'name': 'ghostwu', 'sex': 'male'}

字典相关操作方法:
del能够去除某一项,或许去除全部字典,dict.clear()是清空整个字典. 
dict.pop( key ),删除字典中对应的key和值,并再次来到被删去的值

>>> userinfo
{'email': '[email protected]', 'age': 20, 'name': 'ghostwu', 'sex': 'male'}
>>> type(userinfo)
<type 'dict'>
>>> userinfo['age']=30
>>> userinfo
{'email': '[email protected]', 'age': 30, 'name': 'ghostwu', 'sex': 'male'}
>>> del(userinfo['age'])
>>> userinfo
{'email': '[email protected]', 'name': 'ghostwu', 'sex': 'male'}
>>> userinfo.pop('email')
'[email protected]'
>>> userinfo
{'name': 'ghostwu', 'sex': 'male'}
>>> userinfo.clear()
>>> userinfo
{}
>>> del(userinfo)
>>> userinfo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'userinfo' is not defined
>>> 

 字典有数不完的艺术,比如:keys获取具有的键,values:获取具备的值

1 >>> userinfo={'name':'ghostwu','age':20,'sex':'male'}
2 >>> userinfo.keys()
3 ['age', 'name', 'sex']
4 >>> userinfo.values()
5 [20, 'ghostwu', 'male']

 

系列平常有3个特点: 一,可以依据目录取值 2,能够切成条操作
字符串,元组,列…

python学习笔记壹:数据类型,python学习笔记

Python第26日 连串  二种数据类型  数值  字符串  列表  元组  字典

 

目录

Pycharm使用手艺(转发)

Python第一天  安装  shell
 文件

Python第1天  变量  运算符与表明式  input()与raw_input()差距  字符编码
 python转义符
 字符串格式化

Python第二十六日 连串  5种数据类型  数值  字符串  列表  元组
 字典

Python第九天   流程序调节制   if else条件判别   for循环
while循环

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

Python第陆天   类型调换

Python第7日   函数  函数参数   函数变量   函数重返值  多花色传值  
 冗余参数   函数递归调用   佚名函数   内置函数  
列表表达式/列表重写

Python第玖一日  模块   包   全局变量和放手变量__name__    Python
path

Python第七天  面向对象  类定义   类的性质    类的措施    内部类  
垃圾回收机制   类的承继装饰器

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

Python第拾壹天    卓殊管理  glob模块和shlex模块  
 张开外部程序和subprocess模块  subprocess类  Pipe管道  operator模块  
sorted函数   生成器  walk模块  
hashlib模块

Python第7二天     搜集主机消息     正则表明式  无名分组  
出名分组

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

Python第910日 类别化  pickle模块  cPickle模块  JSON模块
 API的二种格式

Python第九三日  datetime模块 time模块   thread模块  threading模块
 Queue队列模块  multiprocessing模块  paramiko模块  fabric模块
 

 

 

 

 

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

 

 

序列
序列:字符串、列表、元组
队列的七个主要特征是目录操作符切开操作符

  • 目录操作符让我们得以从种类中抓取多个一定类型
  • 切开操作符让我们能够赢得种类的3个切开,即壹部分行列

队列的基本操作

  1. len(): 求连串的尺寸
  2. +: 连接2个序列
  3. *: 重复种类成分
  4. in/not in: 判断成分是不是在种类中
  5. max(): 重返最大值
  6. min(): 重临最小值
  7. cmp(x, y):相比多个系列是不是等于 重返值大于0 ,等于0,小于0
    cmp:遵照字符串比较,字符串比较的标准化正是3个字符贰个字符的相比较,字符依据ASCII码来相比较,字符一比字符2小,所以gene100一稍差于gene二。

 


数值类型

  • 整型  2^32个数字,范围-2,147,483,648到2147483647
  • 长整型  区分普通整型,需求在整数后加L或l。23四伍L,0x3四al
  • 浮点型  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()


元组()类型
元组和列表10分相似
元组和字符串一样是不可变的,不可变的情致是元组里面包车型大巴要素无法改改,比方a[-1]
= xx 会报错

1,能够依据目录取值

1、Python文件类型

1、源代码

hello.py:

1 #!/usr/bin/python
2 print "hello world"

二、字节代码:python源文件经编译后生成的恢宏名称为“pyc”的公文

编写翻译方法(compile.py):

import py_compile
py_compile.compile('hello.py')

下一场试行:

$ python compile.py

会变卦2进制的 hello.pyc 文件

3、优化代码:经过优化的源文件,扩充名字为 pyo

在指令行下实行上边包车型地铁授命优化:

$ python -O -m py_compile hello.py

– 元组能够积存一多种的值

元组平时用在用户定义的函数能够平安地运用一组值的时候,即被利用的元组的值不会改造。

始建元组
t= ()
t= (二,) 一定要加逗号才是元组,不然会当普通字符串对待
t = (‘james’, ‘M’)
t = (‘james’, ‘M’,(一,)) 元组里面富含元组
j = ‘sd’
t = (j, ‘M’) 包罗变量

print t
(‘sd’, ‘M’)

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)是管理1组有序项目标数据结构,即能够在列表中积累1个队列的连串。
列表是可变类型的数据类型
成立列表
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开头 -一:九 -二: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)  在下标前插入2个对象
  • 排序
    list.sort()
  • 反转
    list.reverse()
  • 弹出
    list.pop([index]) 
    重回多少个要素并删除那个成分,参数是下标,未有参数会去除最终3个因素
  • 扩展
    list.extend(iterable) 
    可迭代的,比较append()方法能够增添七个值,l.extend(range(10))
  • 统计
    a = [‘s’,’c’,’c’]
    a.count(‘c’)  总结’c’那几个成分一共有些许个

 

Python合并列表,append()、extend()、+、+=
一.append()
向列表尾部扩展1个新因素,列表只占2个索引位,在原始列表上扩展
贰.extend()
向列表尾巴部分增添贰个列表,将列表中的各个成分都扩展进来,在原始列表上平添
3.+
一向用+号看上去与用extend()同样的功用,但是实际上是生成了三个新的列表存那八个列表的和,只可以用在三个列表相加上
4.+= 功用与extend()同样,向原列表追加一个新因素,在本来列表上加码

澳门葡京备用网址 1


 

字典{}类型

字典是python中的唯一的映照类型(哈希表)
字典对象是可变的,不过字典的键必须采纳不可变对象,3个字典中能够运用分化类别的键值。
跟redis的set类型同样,字典里的key不能够再一次,赋值的时候假若开掘已有key则替换
字典的章程:

  • keys() 再次回到全数key
  • values() 再次回到全部value
  • items() 重回二个列表,key和value在四个元组里

制造字典
dic = {}
dic = dict()

dict()函数
help(dict)

 

字典创制
第一种
dict(([‘a’,1],[‘b’,2]))  #dict()函数情势一
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个和贰个)连串作为参数,重回一个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函数会3遍性把字典的有着键值全部收取来,而iteritems函数只会2次收取一个

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生成器,也是一种生成器


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

 

二,可以切丝操作

二、python 变量

 python变量赋值(可变与不可变)

字符串,元组,列表,字典,都得以视作是系列类型

三、python运算符

1、整数除法 // 

即只取结果中的整数有些:

>>> 3.0 // 2
1.0
>>> 3 // 2
1

贰、求幂运算 **

>>>3**3
27
>>>3**2
9

3、逻辑与、逻辑或、逻辑非

>>> 1>2 and 3>2
False
>>> 2>1 and 3>2
True

>>>1>2 or 3>2
True
>>>1>2 or 1>3
False

>>> not 1>2
True
>>> not 2>1
False

四、运算符优先级:

澳门葡京备用网址 2

作者的操作情状:Ubuntu1陆.0四+python二.柒

四、python 数据类型

1、数字:分整型、长整型、浮点、复数

里头复数(用j代表):

>>> a=3.14j
>>> type(a)
<type 'complex'>
>>> 

2、字符串:单双引号同样

>>> str1="a"
>>> str2='a'
>>> id(str1)
140710100204544
>>> id(str2)
140710100204544
>>> mail="""tom:
...     i am jack
...     goodbye
... """
>>> print mail
tom:
    i am jack
    goodbye

>>> 

切片:[start:stop:step]

即:[开首索引:结束索引:步长值]

开班索引:同别的语言同样,从0开首。种类从左向右边向中,第贰个值的目录为0,最终2个为-一

终止索引:切成块操作符将取到该索引截至,不带有该索引的值。

步长值:暗许是二个随后三个切取,假若为2,则代表进行隔1取一操作。步长值为正时表示从左向右取,要是为负,则意味从右向左取。步长值不可能为0

注明:如果是string[ : ]的方式,那么正是[start:stop]

示例:

>>>exam="abcdefghi"  
>>>print exam[:-1]
abcdefgh  
>>>print exam[2:]
cdefghi  
>>>print exam[:7:2]
aceg  
>>>print exam[:3:-1]
ihgfe

注意:末尾壹行,因为第陆个参数是-1,所以是倒序输出的,但是此时的目录并从未倒序排列

3、列表:管理1组有序项目标数据结构,是可变类型数据,用[]意味着,包罗了三个以逗号隔断的类型。

>>> l=['jim',25,'male']
>>> l
['jim', 25, 'male']
>>> type(l)
<type 'list'>
>>> l[0]
'jim'
>>> l[0]='tom'
>>> l[0]
'tom'
>>> l
['tom', 25, 'male']

空列表:

>>>l=[]

唯有一个值:

>>>l=['abc']

列表常用方法:

取值:list[index] 或者 list[start:end:offset]

追加:list.append(x);

删除:del(list[index]) 或者 list.remove(list[index])

修改:list[index]=x

查找:var in list

>>>l=['a',1]
>>>'a' in l
True
>>>'b' in l
False

4、元组:跟列表类似,只是跟字符串同样是不可变的,即你不能够改改元组(只可以在内部存款和储蓄器中再度成立二个)。

  • 元组通过圆括号中用逗号分隔的项目概念
  • 元组平时用在使说话或用户定义的函数可以安全地行使1组值的时候,即被用的元组的值不会变动

>>>userinfo=("tom", 30, "man")
>>>userinfo[0]
"tom"

空元组:

>>>t=()

单1成分的元组:

>>>t=(1,)

留意,不可能省略逗号

用变量接收元组:

>>> t
('jim', 25, 'man')
>>> name,age,gender=t
>>> name
'jim'
>>> age
25
>>> gender
'man'

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

5、字典:python中天下无双的照射类型(哈希表)

始建格局:

(1){}

>>>dic={0:0,'a':'abc'}
>>>dic[0]
0
>>>dic['a']
'abc'

(2)使用工厂方法dict()

>>> fdict=dict([('x',1),('y',2)])
>>> fdict
{'y': 2, 'x': 1}

(三)fromkeys():字典中的成分具备一样的值,默感到None

>>> d={}.fromkeys(('x','y',0), -1)
>>> d
{'y': -1, 'x': -1, 0: -1}

字典常用方法:

(1)、使用键值访问更新

(2)、del dict1[‘a’]剔除字典中键值为a的要素

(三)、dict一.pop(‘a’) 删除并再次回到键为’a’的要素

(四)、dict一.clear()删除字典全部因素

(5)、del dict壹 删除全数字典

(陆)、str(dict壹) 调换为字符串

(7)、get(key[, msg]) 借使key不存在重返msg(未有为空)值

(八)、dict一.items() 重临键值对元组的列表

>>> d
{'a': 1, 'b': 2}
>>> d.items()
[('a', 1), ('b', 2)]

(九)、dict一.keys() 重临字典中键的列表

>>> d
{'a': 1, 'b': 2}
>>> d.keys()
['a', 'b']

(10)、dict壹.setdefault(key,default=None)
若key存在则赶回其value,否则dict一[key]=default

(1一)、dict1.update(dict二)
将dict第22中学的键值对拉长到字典dict第11中学,若是有重复就覆盖,不然增添。

(12)、len(dict壹) 重回字典中有些许项

>>> d
{'a': 1, 'b': 2}
>>> len(d)
2

6、序列:列表、字符串、元组都以体系

澳门葡京备用网址 ,切开:连串后跟二个方括号,方括号中有1对用冒号隔断的可选数字,数字是可选的,冒号是必须的。如:

>>>exam="abcdefghi"  
>>>print exam[:-1]
abcdefgh  
>>>print exam[2:]
cdefghi  
>>>print exam[:7:2]
aceg  
>>>print exam[:3:-1]
ihgfe

目录:系列后跟一个方括号,方括号中有3个数字(能够是负数)。如:

>>>exam="abcdefghi"  
>>>print exam[0]
a

 

5、连串基本操作

一、len:体系长度

>>>exam="abc"  
>>>len(exam)
3

2、+:连接八个体系

>>>str1="abc"  
>>>str2="d"
>>>str1+str2
abcd

3、*:重复系列成分

>>>str1="abc "  
>>>str1*3
abc abc abc

四、in:剖断成分是不是在连串中

>>>str1="abc "  
>>>'c' in str1
True
>>>'x' in str1
False

伍、max:重回最大值

>>>s='12345'
>>>max(s)
'5'

6、min:重回最小值

>>>s='12345'
>>>min(s)
'1'

7、cmp(tuple一, tuple2):相比多少个类别值是或不是1律

>>>str1='abc'
>>>str2='123'
>>>cmp(str1,str2)
1

>>>str1='1'
>>>cmp(str1,str2)
-1

>>>str1='123'
>>>cmp(str1,str2)
0

六、

一、Python文件类型 壹、源代码 hello.py: 1 # !/usr/bin/python 二 print ”
hello world ” 2、字节代码:python源…

一、字符串类型

>按索引获取,索引从0开始

1 >>> name='ghostwu'
2 >>> name[0]
3 'g'
4 >>> name[1]
5 'h'
6 >>> name[6]
7 'u'
8 >>> 

>切成片操作,第3个冒号的值,表示从哪个索引早先切块。第三个冒号的值,表示从到哪些索引结束(注意:结果不含有那一个岗位)。第2个冒号的值,表示步长

>>> name='My Name Is Ghostwu'
>>> name[0:7]
'My Name'
>>> name[0:7:1]
'My Name'
>>> name[0:7:2]
'M ae'

默许切成块操作为:从左到右。借使升幅为负数,表示从右往左切成片。从后往前数(索引从-1开首), 
type的功用:查看数据类型。

 1 >>> name='My Name Is Ghostwu'
 2 >>> name[-1]
 3 'u'
 4 >>> name[-1:-4]
 5 ''
 6 >>> name[-1:-4:-1]
 7 'uwt'
 8 >>> type(name)
 9 <type 'str'>
10 >>> name[2]
11 ' '
12 >>> name[2:]
13 ' Name Is Ghostwu'
14 >>> name[2:-1]
15 ' Name Is Ghostw'
16 >>> 

字符串别的小才能: 

>len函数,总结长度

>>> str="ghostwu"
>>> len(str)
7

>+号,连接字符串

>>> str="hi "
>>> str2="ghostwu"
>>> str+str2
'hi ghostwu'

 >*号,重复字符串次数,是否很简短,在php中要用str_repeat恐怕循环连接字符串

>>> str="ghostwu"
>>> str*2
'ghostwughostwu'
>>> str
'ghostwu'
>>> 

>in: 剖断元素是不是在种类中

>>> str="ghostwu"
>>> 'g' in str
True
>>> 'x' in str
False
>>> 

>max最大值,min最小值

>>> str="abc123"
>>> max(str)
'c'
>>> min(str)
'1'
>>> 

>cmp(str一,str二)
相比种类值是或不是同样

 1 >>> str="abc"
 2 >>> str2="ab1"
 3 >>> cmp(str,str2)
 4 1
 5 >>> cmp(str2,str)
 6 -1
 7 >>> str2="abc"
 8 >>> cmp(str,str2)
 9 0
10 >>> 

 

二、元组类型

用名称=(item,item,)小括号定义,唯有一项的时候,要加逗号

字符串的痛点:即便用3个字符串,保存有些人的音讯,那么在切除的时候(如人名,年龄,性别)就不太好操作

1 >>> userinfo="ghostwu 20 male"
2 >>> type(userinfo)
3 <type 'str'>
4 >>> userinfo[0:7]
5 'ghostwu'

比如用元组来拍卖

 1 >>> userinfo=("ghostwu","20","male")
 2 >>> type(userinfo)
 3 <type 'tuple'>
 4 >>> userinfo[0]
 5 'ghostwu'
 6 >>> userinfo[1]
 7 '20'
 8 >>> userinfo[2]
 9 'male'
10 >>> 

看,是还是不是非凡轻便?唯有1项时?怎么定义?

>>> userinfo=("ghostwu")
>>> type(userinfo)
<type 'str'>
>>> 

像上面那种概念方式,定义的是3个字符串类型。唯有1项时,供给在末端加个逗号’,’

>>> userinfo=('ghostwu',)
>>> type(userinfo)
<type 'tuple'>
>>> userinfo[0]
'ghostwu'
>>> 

元组定义之后,不能被涂改:

>>> userinfo=("ghostwu",20,"male")
>>> userinfo[0]="zhangsan"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> 

可以接纳类似es六的解构语法,把元组的每1项对应赋值给右侧的变量:

>>> userinfo=('ghostwu',20,'male')
>>> name,age,sex=userinfo
>>> name
'ghostwu'
>>> age
20
>>> sex
'male'

 

三、列表(list)

>中括号定义

>>> list1=[]
>>> type(list1)
<type 'list'>

>>> userinfo=['ghostwu',20,'male']
>>> type(userinfo)
<type 'list'>
>>> userinfo[0]
'ghostwu'
>>> userinfo[1]
20
>>> userinfo[2]
'male'

>列表的切成条操作

 1 >>> userinfo=['ghostwu',20,'male']
 2 >>> userinfo[0:1]
 3 ['ghostwu']
 4 >>> userinfo[0:2]
 5 ['ghostwu', 20]
 6 >>> userinfo[::2]
 7 ['ghostwu', 'male']
 8 >>> userinfo[::]
 9 ['ghostwu', 20, 'male']
10 >>> userinfo[::1]
11 ['ghostwu', 20, 'male']

>列表能够被重复赋值,列表项能够被改动,不过不能够动态索引方式充实,不然报错(索引高出上限)

 1 >>> userinfo=['ghostwu',20,'male']
 2 >>> len(userinfo)
 3 3
 4 >>> userinfo='zhangsan'
 5 >>> len(userinfo)
 6 8
 7 >>> userinfo=[]
 8 >>> len(userinfo)
 9 0
10 >>> userinfo[0]="ghostwu"
11 Traceback (most recent call last):
12   File "<stdin>", line 1, in <module>
13 IndexError: list assignment index out of range
14 >>> userinfo=["ghostwu",20,"male"]
15 >>> userinfo[0]="zhangsan"
16 >>> userinfo
17 ['zhangsan', 20, 'male']
18 >>> userinfo[3]="china"
19 Traceback (most recent call last):
20   File "<stdin>", line 1, in <module>
21 IndexError: list assignment index out of range
22 >>> 

>列表操作:

取值:切丝和目录    修改: list[] = x

>>> userinfo=['ghostwu',20,'male']
>>> type(userinfo)
<type 'list'>
>>> userinfo[0]\
... 
'ghostwu'
>>> userinfo[0:2]
['ghostwu', 20]

修改列表的某壹项时候,地址未有改变,照旧列表本人

>>> userinfo=["ghostwu",20,"male"]
>>> id(userinfo)
140648386293128
>>> userinfo[0]="hello"
>>> id(userinfo)
140648386293128

元组重新被赋值,相当于重新定义了3个新的元组:

>>> userinfo=("ghostwu",20)
>>> type(userinfo)
<type 'tuple'>
>>> userinfo[0]="hello"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(userinfo)
140648386125696
>>> userinfo=("zhangsan",30)
>>> id(userinfo)
140648386125552

添加: list.append()

1 >>> userinfo=["ghostwu",20]
2 >>> userinfo
3 ['ghostwu', 20]
4 >>> userinfo.append("male")
5 >>> userinfo
6 ['ghostwu', 20, 'male']
7 >>> userinfo.append("china")
8 >>> userinfo
9 ['ghostwu', 20, 'male', 'china']

 删除: del(list[])   list.remove(list[]) , 
注意:remove删除的是列表中第壹遍面世的值

 1 >>> userinfo
 2 ['ghostwu', 20, 'male', 'china']
 3 >>> type(userinfo)
 4 <type 'list'>
 5 >>> userinfo.remove(20)
 6 >>> userinfo
 7 ['ghostwu', 'male', 'china']
 8 >>> userinfo.remove("china")
 9 >>> userinfo
10 ['ghostwu', 'male']

>>> userinfo=['ghostwu',20,'ghostwu','male','ghostwu']
>>> userinfo
['ghostwu', 20, 'ghostwu', 'male', 'ghostwu']
>>> userinfo.remove('ghostwu')
>>> userinfo
[20, 'ghostwu', 'male', 'ghostwu']

 1 >>> userinfo
 2 [20, 'ghostwu', 'male', 'ghostwu']
 3 >>> type(userinfo)
 4 <type 'list'>
 5 >>> userinfo.remove('male')
 6 >>> userinfo
 7 [20, 'ghostwu', 'ghostwu']
 8 >>> del( userinfo[1] )
 9 >>> userinfo
10 [20, 'ghostwu']

查找: var in list

1 >>> userinfo
2 [20, 'ghostwu']
3 >>> 20 in userinfo
4 True
5 >>> '20' in userinfo
6 False
7 >>> 'ghostwu' in userinfo
8 True

 

四、字典

她的用法类似于javascript中的json,大括号中用键值对定义,取多少用相应的键

 1 >>> userinfo={'name':'ghostwu', 1 : 20, 'age' : 20, 'sex' : 'male' }
 2 >>> type(userinfo)
 3 <type 'dict'>
 4 >>> userinfo
 5 {1: 20, 'age': 20, 'name': 'ghostwu', 'sex': 'male'}
 6 >>> userinfo['name']
 7 'ghostwu'
 8 >>> userinfo['age']
 9 20
10 >>> userinfo[1]
11 20

字典中的键,能够是字符串,也能够是变量

1 >>> a=10
2 >>> b=20
3 >>> dic={a:'ghostwu','b':'male'}
4 >>> dic
5 {10: 'ghostwu', 'b': 'male'}
6 >>> dic[10]
7 'ghostwu'
8 >>> dic['a']

用类似javascript的for … in语法 遍历字典:

 1 >>> userinfo={'name':'ghostwu','age':20,'sex':'male'}
 2 >>> for key in userinfo:
 3 ...     print key
 4 ... 
 5 age
 6 name
 7 sex
 8 >>> for key in userinfo:
 9 ...     print userinfo[key]
10 ... 
11 20
12 ghostwu
13 male
14 >>> 

为字典扩展1项值

1 >>> userinfo
2 {'age': 20, 'name': 'ghostwu', 'sex': 'male'}
3 >>> type(userinfo)
4 <type 'dict'>
5 >>> userinfo['email']='test@admin.com'
6 >>> userinfo
7 {'email': 'test@admin.com', 'age': 20, 'name': 'ghostwu', 'sex': 'male'}

字典相关操作方法:
del可以去除某一项,只怕去除所有字典,dict.clear()是清空整个字典. 
dict.pop( key ),删除字典中对应的key和值,并回到被剔除的值

>>> userinfo
{'email': 'test@admin.com', 'age': 20, 'name': 'ghostwu', 'sex': 'male'}
>>> type(userinfo)
<type 'dict'>
>>> userinfo['age']=30
>>> userinfo
{'email': 'test@admin.com', 'age': 30, 'name': 'ghostwu', 'sex': 'male'}
>>> del(userinfo['age'])
>>> userinfo
{'email': 'test@admin.com', 'name': 'ghostwu', 'sex': 'male'}
>>> userinfo.pop('email')
'test@admin.com'
>>> userinfo
{'name': 'ghostwu', 'sex': 'male'}
>>> userinfo.clear()
>>> userinfo
{}
>>> del(userinfo)
>>> userinfo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'userinfo' is not defined
>>> 

 字典有大多的主意,举例:keys获取具备的键,values:获取具有的值

1 >>> userinfo={'name':'ghostwu','age':20,'sex':'male'}
2 >>> userinfo.keys()
3 ['age', 'name', 'sex']
4 >>> userinfo.values()
5 [20, 'ghostwu', 'male']

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website