Python学习笔记 - day3 - 数据类型及运算符

时间:2022-10-17 00:23:45

Python的数据类型

  计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值。但是,计算机能处理的远不止数值,还可以处理文本、图形、音频、视频、网页等各种各样的数据,不同的数据,需要定义不同的数据类型。在Python中,能够直接处理的数据类型有以下几种:数值型、字符串型、列表型、元组型、字典型。

数值类型

  顾名思义就是数字类型,但数字类型内部又分为:整型、浮点型、长整型、复数型

整数类型

  整数类型的范围是2**32,其中包含正数和负数(2的31次方个正和2的31次方的个负数,所以它的范围是-2147483648 ——— 214748364。
  PS:查看一个数据的类型使用type(数据)方法  
In [1]: a=1
In [2]: type(a)
Out[2]: int # int表示为整型
In [18]: type(2/1)
Out[18]: int

浮点型

  浮点类型就是带小数点的,多余的位数会被四舍五入。
  整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。
In [3]: a=1.23
In [4]: type(a)
Out[4]: float  # float表示的是浮点数
In [19]: type(2.0/1)
Out[19]: float

长整型

  用l或L表示,当我们赋值的时候使用l可以把变量赋值为长整型,注意在Python3中已经取消了长整型这个格式。
In [11]: a=1299999999999999999999999999999999999999999
In [12]: type(a)
Out[12]: long    #long表示长整型
In [13]: a
Out[13]: 1299999999999999999999999999999999999999999L
In [15]: a=123l
In [16]: type(a)
Out[16]: long
#只有python2.x中有长整型的概念,python3.x只有整型

复数型

  用j表示,当我们赋值的时候使用j可以把变量赋值为复数型,python对复数提供内嵌支持。(其他大部分软件没有)
  复数一般用于科学计算,我们日常一般不会使用,这里知道即可。
In [20]: type(123j)
Out[20]: complex # 表示复数类型

字符串类型

  字符串是以单引号'或双引号"括起来的任意文本,比如'abc'"xyz"等等。请注意,''""本身只是一种表示方式,不是字符串的一部分,因此,字符串'abc'只有abc这3个字符。如果'本身也是一个字符,那就可以用""括起来,比如"I'm OK"包含的字符是I'm,空格,OK这6个字符。有三种方法定义字符串:单引号,双引号,三引号。
str='this is string'
str="this is string"
str='''this is string''' #也可以是三个双引号,三个引号可以多行注释但是不能单双混合
    其中三重引号除了能定义字符串以外,还可以表示注释。

字符串的基本操作

  字符串是一个序列,可以通过索引和切片去操作

索引

  类似数组的下标:
In [3]: a='1234567'
In [4]: a[0] -->#下标从0开始,0表示第一个数
Out[4]: '1'
In [5]: a[3] -->#表示第四个数
Out[5]: '4'

切片

  类似shell变量的截取:
 In [14]: a='abcd'
In [15]: a[0:2]
Out[15]: 'ab'
#从第0个开始截取2个字符,其中0可以省略 In [14]: a='abcd'
In [16]: a[:-1]
Out[16]: 'abc'
#默认是从左往右(前往后),带减号,表示从右往左(后往前),-1表示最后一个字符(a='abcd',-1的值是d,也就是3,顾a[:-1],就等于a[0:3]) In [14]: a='abcd'
In [17]: a[1:]
Out[17]: 'bcd'
#从1开始截取到最后 In [14]: a='abcd'
In [20]: a[::2]
Out[20]: 'aceg'
#步长为2,表示从0开始步长为2,(取0,2,4,6) In [26]: a
Out[26]: 'abcdefg'
In [27]: a[-5:-1]
Out[27]: 'cdef'
#表示倒着取,从倒数第五个取到倒数第一个(不包含倒数第一,要想取可以使用a[-5:]) In [29]: a
Out[29]: 'abcdefg'
In [30]: a[0:5:1]
Out[30]: 'abcde'
In [31]: a[0:5:2]
Out[31]: 'ace'
#从0开始取到第5个,步长为1,步长为2 In [32]: a
Out[32]: 'abcdefg'
In [34]: a[-1::-1]
Out[34]: 'gfedcba'
#从后往前取,步长为-1,表示每次倒着取1个,由于没有指定结尾,默认到最后,所以就把数字逆了过来。 In [36]: a
Out[36]: 'abcdefg'
In [38]: a[::2][:2]
Out[38]: 'ac'
#表示先每隔2个取出来,然后从头开始取2个。

字符串的切片操作

字符串的内置方法

  字符串是Python中的主要数据类型,其内置了非常多的方法,主要方法如下:
 # 功能:首字母大写
# 调用方式:string.capitalize()
# 例:
name = 'hello' name.capitalize() #结果:
'Hello'

capitalize

 # 3.x新增 字符串转换为小写,可以转换各种语言大小写(法语、德语...)
# 用法 :string.casefold() 例子:
name = 'HELLO'
name.casefold() 结果: 'hello'

casefold

 # 功能:字符串转换为小写,只能转换英文字母
# 用法:string.lower() 例:
name = 'World'
name.lower() 结果:
'world'

lower

 # 功能:文本填充,width为字符串的总长度,str居中然后两端用fillcharacter填充,fillchar默认为空格
# 用法:str.center(width,filechar=None) 例:
name = 'hello'
name.center(7,'*') 结果:
*hello*

center

 # 功能:sub为统计的字符串(子序列),统计sub出现的次数,start为起始位置,end为结尾位置
# 用法:str.counter(sub,start=None,end=None) 例:
name = 'hello'
name.counter('l') 结果:
2

counter

 # 功能:以suffix为开头,返回bool值,start起始位置,end结束位置
# 用法:str.startswith(suffix,start=None,end=None) 例:
name = 'Hello'
name.startswith('H') 结果:
True

startswith

 # 功能:以suffix为结尾,返回bool值,start起始位置,end结束位置
# 用法:str.endswith(suffix,start=None,end=None) 例:
name = 'world'
name.endswith('d') 结果:
True

endswith

 # 功能:找到tab键,然后对它做一个特殊的替换,20表示,两个\t之前的总和(开头没有的话,默认从开头开始)
# 用法:str.expendtabs(20) 例:
name = 'a\tb\tc\t'
name.expendtabs(3) 结果:
'a b c' 解读:中间两个空格,算上单字符串和空格,总长度为3。

expendtabs

 # 功能:找到sub在str中的位置,如果找到返回index(匹配到第一个),找不到返回-1
# 用法:str. find(sub,start=None,end=None) 例:
name = 'hello'
name.find('l') 结果:
2

find

 # 功能:格式化字符串,位置占位符为{0},{1}
# 用法:str.format() 例:
print("Hello {0},I'am {1}".format('daxin','')) 结果:
Hello daxin,I'am 20 扩展:
可以命名占位符{name},{age},那么赋值的时候就需要 name=daxin,age=2

format

 # 功能:格式化字符串,只不过传递的值是一个字典
# 用法:str.format_map() 例:接上个例子
print("hello {name},I am {age}".formar({'name':"daxin",'age'=20}))

format_map

 # 功能:查询sub在str中的index,如果不存在,会报错
# 用法:str.index(sub) 例:
name = 'hello world'
name.index('w') 结果:
6

index

 # 功能:判断str中是否包含数字,字母,汉字等等,然后bool
# 用法:str.isalnum() 例:
name = 'abc123你好'
name.isalnum() 结果:
True

isalnum

 # 功能:判断字符串是否都为字母,返回bool类型
# 用法:str.isalpha() 例:
name = 'abc123'
name.isalpha() 结果:
False

isalpha

 # 功能:判断是否只包含阿拉伯数字,'123'
# 用法:str. isdecimal() 例:
name = ''
name.isdecimal() 结果:
True

isdecimal

 # 功能:只能认识阿拉伯数字、以及特殊符号的数字,'123','②'
# 用法:str. isdigit() 例:
name = '123②二'
name.digit() 结果:
False

isdigit

 # 功能:只能认识阿拉伯数字、以及特殊符号的数字,以及中文数字'123','②','二'
# 用法:str. isnumerice() 例:
name = '123②二'
name.isnumerice() 结果:
True

isnumerice

 # 功能:判断对象是否可以成为标识符(变量名)来用,不会判断关键字
# 用法:str.isidentifier() 例:
name = '9hello'
name.isidentifier() 结果:
False

isidentifier

 # 功能:str是否都是小写,返回bool
# 用法:str. islower() 例:
name = 'hello'
name.islower() 结果:
True

islower

 # 功能:str是否是大写,返回bool类型
# 用法:str. isupper() 例:
name = 'HELLO'
name.isuper() 结果:
True

isupper

 # 功能:把str转换为大写
# 用法:str.upper() 例:
name = 'hello'
name.upper() 结果:
'HELLO'

upper

 # 功能:判断对象是否可以被打印(不包含隐藏字符,例如\n,这种打印不出来的,就会返回False)
# 用法:str.isprintable() 例:
name = 'hello\n'
name.isprintable() 结果:
False

isprintable

 # 功能:判断对象是否是空格
# 用法:str.isspace() 例:
name = ' '
name.isspace() 结果:
True

isspace

 # 功能:判断对象是否是标题,既首字母大写(既每个单词的首字母大写)
# 用法:str.stitle() 例:
name = 'Hello World'
name.istitle() 结果:
True

istitle

 # 功能:连接,用于把可迭代对象的每个元素用 什么 连接起来,可迭代对象的元素必须是str
# 用法:'分隔符'.join(iterable) 例1:
a = 'hello'
'*'.join(a)
结果:
h*e*l*l*o 例2:
'*'.join([ str(i) for i in range(10)])

join

 # 功能:左填充,fillchar为填充的字符
# 用法:str.ljust(width,fillchar=None) 例:
name = 'hello'
name.ljust(10,'*') 结果:
*****hello

ljust

 # 功能:右填充,fillchar为填充的字符
# 用法:str.rjust(width,fillchar=None) 例:
name = 'hello'
name.rjust(10,'*') 结果:
hello*****

rjust

 # 功能:左去除,既删除左边的空格换行符和制表符
# 用法:str.lstrip() 例:
name = '*hello*'
name.lstrip('*') 结果:
'hello*'

lstrip

 # 功能:右去除,既删除右边的空格换行符和制表符
# 用法:ste.rstrip() 例:
name = '*hello*'
name.rstrip('*') 结果:
'*hello'

rstrip

 # 功能:创建对应关系,既a对应1,b对应2,c对应3
# 用法:str.maketrans('abc','123') 例:
m = str.maketrans('abc','')
name = 'abc123'
v = name.translate(m)
print(v) 结果:
''

maketrans

 # 功能:和maketrans连用,用来表示按照什么规则进行翻译解释,例子如上
# 用法:str.translate()

translate

 # 功能:根据split进行分割,从左开始,只分割遇到的一个split,并且保存分隔符,返回的对象为元祖
# 用法:str.partition('split') 例:
name = 'Hello|World'
name.partition('|') 结果:
('hello','|','World')

partition

 # 功能:字符串的替换,把src替换为dst,counter为替换几次
# 用法:str.replice('src','dst',counter=None) 例:
name = 'Hello World'
name.replice('H','h') 结果:
'hello World'

replice

 # 功能:右查找,既丛字符串的右边开始查找sub,并返回它对应的index
# 用法:str.rfind('sub') 例:
name = 'hello'
name.rfind('l') 结果:
3

rfind

 # 功能:从右边查找sub的index,如果sub在str对象中不存在,那么会报valueError异常
# 用法:str.rindex('sub') 例:
name = 'hello'
name.rindex('l') 结果:
3

rindex

 # 功能:既从右边开始,对找到的第一个split进行分割,返回值为元祖(包含分隔符)
# 用法:str.rpatition('split') 例:
name = 'hello'
name.rpatition('l') 结果:
('hel','l','o')

rpatition

 # 功能:把字符串默认从左开始对象使用split进行分割,默认会对所有分割符进行分割,num可以指定分隔符的个数
# 用法:str.split('split',num=None) 例1:
name = 'hello world'
name.split('l')
结果:
['he','','o wor','d'] 例2:
name = 'hello world'
name.split('l',1)
结果:
['he','lo world']

split

 # 功能:把字符串从右开始使用split进行分割,在不指定num的情况下和split相同
# 用法:str.rsplit('split',num=None) 例:
name = 'hello world'
name.rsplit('l',1) 结果: 
['hello wor','d']

rsplit

 # 功能:以什么为分行符,功能等同于split('\n')
# 用法:str.splitlines(keepends=None) 例:
name = 'hello\nworld'
name.splitlines('\n')

splitlines

 # 功能:去除两边的string,默认是移除空格换行及制表符。
# 用法:str.strip('string') 例:
name = ' hello '
name.strip() 结果:
'hello'

strip

 # 功能:大小写转换,既把对象的大写转换为小写,小写转换为大写
# 用法:str. swapcase() 例:
name = 'Hello'
name.swapcase() 结果:
'hELLO'

swapcase

 # 功能:把单词的首字母换成大写
# 用法:str.title() 例:
name = 'hello'
name.title() 结果:
'Hello'

title

 # 功能:在字符串的左边填充0,width为总长度
# 用法:str.zfill(width) 例:
name ='hello'
name.zfill(10) 结果:
'00000hello'

zfill

 # 功能:把字符串转换为二进制(字节类型),encodinf=UTF-8,表示转换的时候按照UTF-8进行编码
# 用法:str.encode(encoding = 'UTF-8') 例:
name = '你好'   
name.encode(encoding='UTF-8') 结果:
b'\xe4\xbd\xa0\xe5\xa5\xbd' 扩展:
也可以用其他的编码类型如:gbk

encode

PS:

# format补充
print('{} * {} = {:5}'.format(1,2,3) # 这里说的括号中的:5表示当前元素替换占用5个位置
print('{} * {} = {:<5}'.format(1,2,3) # 这里的<表示左对齐,默认情况下是右对齐,当前这里也可以用>表示右多对齐 # 对齐符下的括号嵌套
print('{} * {} = {:>{}}'.format(1,2,3, 2 if True else 3) # 这里按照括号边界来区分,很明显嵌套在括号里面的的占位符是4。
# 如果不是用在对齐符中,那么就无法进行嵌套

序列类型

  字符串、列表和元组都是序列的一种,序列的两个主要特点是索引操作符和切片操作符
  索引操作符让我们可以从序列中抓取要给特定的项目
  切片操作符让我们能够获取序列的一个切片,即一部分操作

序列类型的基本操作方法

  序列同样支持索引和切片操作,但是字符串、列表、元组的索引和切片又有些许不通

len()

  计算字符串的长度
In [7]: a='123'
In [8]: len(a)
Out[8]: 3
In [9]: len('123')
Out[9]: 3

+

  加号在这里并不是加减乘除的意思,而是用来连接两个序列
In [10]: a
Out[10]: '123'
In [11]: a + '4'
Out[11]: '1234'
#字符串和数字不能连接到一起

*

  重复序列元素(字符串的时候)
In [18]: '#' * 10
Out[18]: '##########'
#当变量为数字的时候就为乘了。

in

  判断元素是否在序列中
In [23]: a = 'abcd'
In [24]: 'a' in a
Out[24]: True
#当字符串在某个序列中的时候返回真,否则返回假(not in表示不在)

max(),min()

  求最大值和最小值
In [25]: max(a)
Out[25]: 'd'
In [26]: min(a)
Out[26]: 'a'
In [27]: a
Out[27]: 'abcd'

  注意:如果对字符进行对比,程序内部会把字符转换成ascii码对应的数字进行比较。

 >>> ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
>>>

字符转换成ascii码对应的数字

cmp()

  比较两个序列是否相等

#若相等则返回0,若前大于后则返回正数,若后大于前则返回负数
In [30]: cmp("123","456")
Out[30]: -1
In [33]: cmp("789","456")
Out[33]: 1
In [34]: cmp("456","456")
Out[34]: 0 #注意cmp的比较是从左向右开始比对的,大于就返回1,小于就返回-1,等于就继续向后比对
In [43]: cmp('5','456')
Out[43]: 1
In [44]: cmp('45','456')
Out[44]: -1
In [45]: cmp('455','456')
Out[45]: -1
In [46]: cmp('457','456')
Out[46]: 1

元组概念

    元组(类型为 tuple)和列表十分相似
    元组和字符串一样是不可变的

元祖的特点

  元组可以存储一系列的值,使用括号来定义。
  元组通常用在用户定义的函数能够安全的采用一组值的时候,即被使用的元组的值不会改变,不可变的含义是:不能改变这个值中的某个字符。
  元祖也通常用来接收函数的返回值。
In [8]: a='123456'
In [9]: a[-1]
Out[9]: '6'
In [10]: a[-1]=1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-10-1ad23d7f375d> in <module>()
----> 1 a[-1]=1
TypeError: 'str' object does not support item assignment
In [11]:
#变量a是可以被定义成任何值的,但是不能在定义之后,修改里面的值,如果想要修改就需要重新定义这个变量
In [11]: a='123451'
In [13]: a[-1]
Out[13]: '1'

定义一个元组

    使用()来表示定义的是元组,但是如果元组里面的值只有一个的话,需要加在值后面加上,(逗号),表示是一个元组。
    另外,元组中可以同时储存不同类型的数据,也可以引用其他元组。
In [18]: t=(1)
In [19]: type(t)
Out[19]: int
In [20]: t=(1,)
In [21]: type(t)
Out[21]: tuple # tuple表示元组类型 #引用其他元组
In [22]: a=(1,2,3)
In [23]: t=('123',a)
In [24]: t
Out[24]: ('123', (1, 2, 3)) #通过索引只引用某一个值
In [27]: t=('123',a[1])
In [28]: t
Out[28]: ('123', 2)

元祖的基本操作方法

  元组和其他数据类型相同,它支持的操作如下。

元祖的拆分

    通过变量去接收元组中的值
In [34]: a=('123','456')
In [35]: first,second=a   --> # 定义first接收元组的第一个值,second接收元组的第二个值
In [36]: first
Out[36]: '123'
In [37]: second
Out[37]: '456'
#注意接收值的变量要与元组中的值的个数保持一致,若元组中有3个值,必须定义三个变量去接收,否则无法接收(当元组中有两个值的时候,用一个变量去接不会报错,但是也还是用元组的形式表达)
  PS:假如元祖中有三个元素,那么我们可以定义3个变量来接受元祖的值,如果元祖中有4个元素,那么我们只能通过定义1个或者定义4个来接受,定义1个就等于元祖复制,定义4个才表示接受元素
  PS:如果我们不想要某个元素的时候,可以使用_,来获取,分割元组的时候可以有如下操作。
 >>> a = ('a','b','c','d')
>>> a,b,_,d = a
>>> a
'a'
>>> b
'b'
>>> d
'd'
>>>

_忽略部分元素的方法

元组的方法

    如果安装了ipython可以通过tab键查看元组的方法,如果没有安装,就需要使用dir(元组名)去查看了
# 会列出一些内饰的属性,和方法
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>>
# 已__开头的先忽略,后面会讲,所以可以看到有两个方法。 # 使用help查看使用方法
In [3]: help(a.count)
count(...)
T.count(value) -> integer -- return number of occurrences of value # a.count(value) 用来统计value在元组中出现的次数,不存在返回0。
In [4]: a=('1','2','3')
In [7]: a.count("4")
Out[7]: 0
In [8]: a.count("1")
Out[8]: 1 # a.index(value) 用来返回value在元组中的索引,如果value不在元组中,则会报错。如果有多个,默认返回第一个(可以指定从哪个索引开始查找到某个索引结束,指定范围区间)
In [4]: a=('1','2','3')
In [9]: a.index('1')
Out[9]: 0
In [10]: a.index('3')
Out[10]: 2
>>> t1
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
>>> t1.index('a',5,7)
6

列表类型

  列表(类型为 list)是处理一组有序项目的数据结构,即可以在列表中存储一个序列的项目。
  列表是可变类型的数据,创建列表使用[]中括号。

列表的基本操作

  list是一种有序的集合,可以随时添加和删除其中的元素。它的方法有很多,这里列举主要的方法。

创建一个空的列表

# 1、创建一个空列表
list1 = []
list2 = list() # 工厂函数 # 2、创建列表并赋值
list3 = ['a',1,2] # 3、列表可以包含变量,元组,列表等
In [15]: a=123
In [16]: b=['123',a,(1,),["hello","python"]]
In [17]: b
Out[17]: ['123', 123, (1,), ['hello', 'python']]
In [24]: len(b)
Out[24]: 4
#一共有4个变量 # 4、列表的值是可以改变的
In [25]: b
Out[25]: ['123', 123, (1,), ['hello', 'python']]
In [26]: b[0]
Out[26]: '123'
In [27]: b[0]=456
In [29]: b
Out[29]: [456, 123, (1,), ['hello', 'python']]

列表的追加

  使用append在list的后面(右边)

In [30]: a=[]
In [31]: type(a)
Out[31]: list
In [32]: a.append("linux")
In [33]: a
Out[33]: ['linux']

列表的组合

  使用+,对多个列表进行拼接

In [32]: a = [456, 123, (1,)]
In [33]: b = [['hello', 'python'], 'linux']
In [34]: b + a
Out[34]: [456, 123, (1,), ['hello', 'python'], 'linux']
In [35]: (b + a) * 2 # 重复2次
Out[35]:[456, 123, (1,), ['hello', 'python'], 'linux', 456, 123, (1,), ['hello', 'python'], 'linux']
>>>

列表的删除

  使用list的remove方法删除一个元素

In [38]: b = [456, 123, (1,), ['hello', 'python'],'love']
In [39]: b.remove('love')
In [40]: b
Out[40]: [456, 123, (1,), ['hello', 'python']]
#直接移出元素名,如果有两个,则默认删除匹配的第一个。 In [55]: b
Out[55]: [123, 456, ['hello', 'python'], '123', (1,)]
In [56]: del b[0]
In [57]: b
Out[57]: [456, ['hello', 'python'], '123', (1,)]
#如果知道变量的索引可以直接通过del来进行删除,del还可以直接删除变量

列表的反转

  使用list的reverse方法进行原地倒序。

In [41]: b = [456,123, (1,),['hello', 'python']]
In [42]: b.reverse()
In [43]: b
Out[43]: [['hello', 'python'], (1,), 123, 456]  

列表的插入

  使用list的insert进行数据的插入

In [47]: b
Out[47]: [456, 123, (1,), ['hello', 'python']]
In [48]: b.insert(0,'123')
In [49]: b
Out[49]: ['123', 456, 123, (1,), ['hello', 'python']]
# 在索引0的位置插入一个元素‘123’

查找列表中变量

In [62]: b
Out[62]: [456, ['hello', 'python'], '123', (1,)]
In [63]: '123' in b
Out[63]: True
In [65]: "a" in b
Out[65]: False
# 存在返回True,否则返回False

变量的修改

In [68]: b
Out[68]: [456, ['hello', 'python'], '123', (1,)]
In [69]: b[0]='123'
In [70]: b
Out[70]: ['123', ['hello', 'python'], '123', (1,)]
# 修改b的索引0的元素值为‘123’

列表里面嵌入列表,并插入数据

In [71]: b=[] # 定义一个空列表
In [72]: a=[b,'123','456']
In [73]: a
Out[73]: [[], '123', '456']
In [74]: a[0].append("linux") # 向签到的b(空列表)中插入数据
In [75]: a
Out[75]: [['linux'], '123', '456']

删除并列出列表中的某个值

  不加下标,表示删除并打印最后一个值,使用list的pop方法,弹出并打印指定的索引元素,如果不指定元素,则从右开始依次弹出一个

In [75]: a
Out[75]: [['linux'], '123', '456']
In [76]: a.pop(1)
Out[76]: '123'
In [77]: a
Out[77]: [['linux'], '456']

添加可迭代的值

  可迭代:可以理解为可以使用for循环等,挨个取出的值的列表

  列表,字符串,序列,元组 都属于可迭代的对象

In [125]: a
Out[125]: [1, 3, 5, 7, 9]
In [126]: a.extend('2468')
In [127]: a
Out[127]: [1, 3, 5, 7, 9, '2', '4', '6', '8']
In [128]: b=(1,2,3,4)
In [129]: a.extend(b)
In [130]: a
Out[130]: [1, 3, 5, 7, 9, '2', '4', '6', '8', 1, 2, 3, 4]
In [131]:
In [131]: c=123
In [132]: a.extend(c)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-132-49130b702eb2> in <module>()
----> 1 a.extend(c)
TypeError: 'int' object is not iterable
In [133]: # c是int型,不是可迭代,所以会报类型错误。

列表的组合

  zip(),可以把两个列表组合成一个,前一个列表去一个,后列表取一个

In [5]: list1=['Name','age']
In [6]: list2=['Tom',20]
In [7]: zip(list1,list2)
Out[7]: [('Name', 'Tom'), ('age', 20)]

字典类型

    使用大括号定义,是Python中唯一的映射类型(哈希表)
    字典对象是可变的,但是字典的键必须使用不可变对象,一个字典中可以使用不同类型的key。像元组,字符串等都是不可变的,都可以作为key。而列表是可变的,无法作为key。key是唯一的

字典的方法

  字典有很多的方法,这里仅列举常用的方法,其他方法可以使用dir(dict)查看

    1. keys() 获取字典的key
    2. values() 获取字典中所有的values
    3. items() 把字典转换成列表
    4. get() 如果字典中有该key,则返回key值,如果没有,则返回空,也可以自己定义返回值
    5. dic.get('Name','python'),如果存在name,则返回values,否则返回Python  
    6. has_key('key') 判断key的是否存在,存在返回True,否则返回False  
    7. dic1 = dic.copy() 拷贝字典到一个新的字典中去  
    8. clear() 清除字典中的元素  
    9. pop() 删除一个key,同时打印该key的value,如果key不存在,则返回keyerror,或者指定返回值 dic.pop('name',True)
    10. update() 把一个字典更新(添加)到另一个字典中  
    11. fromkeys(s,value) 把序列s,作为字典的key,如果不给value,则默认是none,如果指定value,那么所有key对应的值都为value  

字典的操作示例  

  上面列举了字典的常用方法,下面对部分方法进行举例

创建字典

dic={}
a=dict()
dict(x=10,y=20)
dict([('a',10),('b',20)])
# 使用dict函数时,必须是以元组的形式创建。

把数据存入字典

  把数据添加到字典中
dic = {}
dic['name'] = 'daxin'
dic['age'] = 18

for 循环打印字典

for i in d1:print i,d1[i]
# 取出字典中的key,同时可以根据key来取出value for k,v in d1.items():print k,v
# 把字典的值转换为列表,然后利用k和v来接受列表中元组的key和value # for 循环的知识将在下一章进行讲解 

字典练习

    读取键盘输入,存入到字典中,并打印
#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂ info = dict()
name = raw_input('Please input name: ')
age = raw_input('Please input age: ')
sex = raw_input('Please input sex: ')
info['name'] = name
info['age'] = age
info['sex'] = sex
print info.items()
for k, v in info.items():
print "%s:%s " % (k, v)

PS:以上代码示例均在Python 2.7上进行测试! Python 3.x 会有区别!

类型转换

  注意虽然在Python中有很多的数据类型,但是这些类型是可以相互转换的,那么就要用到了俗称工厂函数的东西:str、list、dict、tuple等等。

  • str():用于把整型、浮点型等转换为字符串
  • list():用于把一个可迭代对象转换为列表
  • dict():把一个可迭代对象(每次迭代返回两个数据),转换为字典
  • tuple():把一个可迭代对象转换为元组
# 1、 把数字转换成字符串
>>> a = 10
>>> type(a)
<class 'int'>
>>> b = str(a)
>>> type(b)
<class 'str'>
>>> print(b)
10 # 2、把list转换成字符串
>>> a = ['h','e','l','l','o']
>>> ''.join(a)
'hello'
>>>
# 注意list转换为字符串要使用join,不能用str # 3、使用dict转换字典
>>> c = [(1,2),(3,4)]
>>> dict(c)
{1: 2, 3: 4}
>>>

注意:

  工厂函数,还可以直接用来创建一个空对象。

>>> d = dict()
>>> d
{}
>>> e = str()
>>> e
''
>>> f = list()
>>> f
[]
>>>

运算符表达式

  python运算符:赋值运算符、算数运算符、关系运算符、逻辑运算符
  python表达式:是将不同的数据(包括变量、函数)用运算符号按一定规则连接起来的一种式子。

赋值运算符

  = 表示赋值,当把数字赋值给一个变量的时候不用加引号,而赋值字符串给变量的时候就需要加引号了,否则python认为你赋值的是另一个变量。
  =:x=3 ,y='abc'
  += :x+=2,表示x=x+2
  -=:x-=2,表示x=x-2
  *=:x*=2,表示x=x*2
  /=:x/=2,表示x=x/2
  %=:x%=2,表示取余,x对2取余数,加入x=6,那么取余为0
PS:Python下不用指定变量的类型,它会自动根据你赋值的类型来定,使用type(x) 来查看变量的类型。

算数运算符

  + 加 用来计算数字,如果字符串、列表等相加,等于是把两个对象拼到一起
  - 减
  * 乘
  / 除,4/3,默认是整除,为了得到小数,可以把其中一个变量变成浮点型,4.0/3或4/3.0
  // 表示只取整数,4.0/3 答案是1.33333,如果用4.0//,因为取整则,答案是1
  % 取余数
  ** 表示乘方 2**3 表示2的3次方

关系运算符

  返回值为布尔值:true or false
  > 1>2,值是false
  < 1<2,值是true
  >= 1>=2,值是false  
  <= 1<=2,值是true
  == 1==2,值是flase
  !=    1!=2,值是true

逻辑运算符

  返回值为布尔值:true or false
  and:逻辑与,只要有1个是false那么值就是false,1==2 and 1<2 ,值是false, 1!=2 and 1<2,值是true
  or:逻辑或,只要有一个是true那么值就是true,1=2 and 1<2 ,值是true
  not:逻辑非,取反 not 1<2,值是true

其他特殊符号

  in/no in 成员测试,测试一个元素是否在一个序列中
  is /is not 统一性的测试

练习

    写一个四则运算器,从键盘读取数字可以使用input()或raw_input()
    input()函数,一般用来接收数字,当我们输入字符串的时候,它会报错,如果需要用字符串那么需要用引号引起来
    raw_input()函数,一般用来接收字符串,当我们输入数字的时候,它也会用引号引起来,表示是字符串

input方式

#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂ num1 = input("Please input a number:")
num2 = input("Please input a number:")
print " %s + %s = %s " % (num1,num2,num1+num2)
print " %s - %s = %s " % (num1,num2,num1-num2)
print " %s * %s = %s " % (num1,num2,num1*num2)
print " %s / %s = %s " % (num1,num2,num1/num2)

raw_input

#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂ num1 = int(raw_input("Please input a number:"))
num2 = int(raw_input("Please input a number:"))
print " %s + %s = %s " % (num1,num2,num1+num2)
print " %s - %s = %s " % (num1,num2,num1-num2)
print " %s * %s = %s " % (num1,num2,num1*num2)
print " %s / %s = %s " % (num1,num2,num1/num2)

小结

#把input输入的数字保存到变量num1中
#把input输入的数字保存到变量num2中
#print打印,%s表示字符串型占位符,占位符需要用“”引起来,前面几个占位符,就需要用传递几个值。外面的% 表示后面是传递的值,多个值用括号括起来
#由于raw_input是以字符串格式存储的,所以如果输入的数字并且需要计算,那么就需要强制转换为整型(int)
#这里如果求余,需要使用%,但是%和占位符的%会产生冲突,为了格式化这个符号,可以使用%%来表示

关于Print的小技巧

  在print中或者字符串定义的时候使用r模式,可以方便的输出带有特殊符号的字符串或提示信息。
print(r'hello \nworld')
# 打印时,并不会去解释\n,而是直接会输出\n str = r'hello \nworld'
# 存入的变量字符串,也不会去解释\n。

  由于数据类型比较多,每个类型的方法也比较多,很多我们都记不过来,所以这里我们只需要记住常用的方法,其他的方法可以使用帮助来查询。

  这里主要使用三种方式进行查询:

  • dir():获取对象的方法
  • help():获取对象的方法以及用法说明
  • PyCharm:按住command点击类型,即可查看源码。从源码中查看对象类型的方法。
>>> help(dict)
Help on class dict in module builtins: class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
| Methods defined here:
|
| __contains__(self, key, /)
| True if D has a key k, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self, /)
| Return repr(self).
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| fromkeys(iterable, value=None, /) from builtins.type
| Returns a new dict with keys from iterable and values equal to value.
|
| get(...)
| D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
| If key is not found, d is returned if given, otherwise KeyError is raised
|
| popitem(...)
| D.popitem() -> (k, v), remove and return some (key, value) pair as a
| 2-tuple; but raise KeyError if D is empty.
|
| setdefault(...)
| D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None >>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>

注意:

  __开头的是Python的内置方法,这个在类的时候,大部分会讲到。