Python基础一

一、数据类型和变量

　　python的数据类型包括：整数、浮点数、字符串、空值、布尔值；

　　整数

　　Python可处理任意大小的整数，在程序中的表示方法和数学上的写法完全一样

　　浮点数

　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

　　字符串

　　字符串是以''或""括起来的任意文本。

　　布尔值

　　布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（要特别注意大小写），也可以通过布尔运算计算出来。

　　空值

　　空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

　　变量和常量

　　在计算机中，变量就是用来在程序运行期间存储各种需要临时保存可以不断改变的数据的标识符，一个变量应该有一个名字，并且在内存中占据一定的存储单元，在该存储单元中存放变量的值。而所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量。

二、数据运算

　　python语言支持以下几种运算

　　算术运算

　　比较运算

　　Assignment Operators

　　二进制运算

　　关系运算

　　验证运算

　　算术运算

　　以下例子a = 10 , b= 20

运算符	描述	示例
+	加法运算	a + b 得 30
-	减法运算	a - b 得 -10
*	乘法运算	a * b 得 200
/	除法运算	b / a 得 2
%	取模 - 将%号左边的值除以%号右边的值并且将得到的结果的余数返回	10%5得0 ，10%3 得1， 20%7 得6
**	幂 - 返回x的y次幂，就是返回多少次方	2**8 得256
//	取整除 - 返回x除以y的商的整数部分	9//2得4 ， 9.0//2.0得4.0

比较运算

　　以下例子a = 10 , b= 20

运算符	描述	示例
==	判断两个对象是否相等	(a == b) is not true.
!=	判断两个对象是否不相等	(a != b) is true.
<>	判断两个对象是否不相等	(a <> b) is true. 与 != 运算符一样.
>	大于 - 返回a是否大于b	(a > b) is not true.
<	小于 - 返回a是否小于b	(a < b) is true.
>=	大于等于 - 返回a 是否大于等于b	(a >= b) is not true.
<=	小于等于 - 返回a 是否小于等于b	(a <= b) is true.

赋值运算

运算符	描述	示例
=	赋值 - 将右边的值赋值给左边的变量名	c = a + b 将会把a+b的结果赋值给c
+=	自加赋值 - 将+=号左边的值与+=号右边的值相加，然后再把结果赋值给+=号左右的值	c += a相当于 c = c + a
-=	自减赋值	c -= a相当于 c = c - a
*=	自乘赋值	c = a 相当于 c = c a
/=	自除赋值	c /= a 相当于 c = c / a
%=	自取模赋值	c %= a 相当于 c = c % a
**=	自求幂赋值	c = a 相当于 c = c a
//=	自取整赋值	c //= a 相当于 c = c // a

　　按位运算(二进制运算)

　　计算机处理数据的时候都会把数据最终变成0和1的二进制来进行运算，也就是说，计算机其实只认识0和1，那按位运算其实就是把数字转换成二进制的形式后再进行位运算的，唉呀，说的好迷糊，直接看例子，我们设定a=60; b=13; 要进行位运算，就得把他们先转成2进制格式，那0和1是如何表示60和13的呢？学过计算机基础的人都知道，计算机最小的存储单位是字节，也就是说一个数字、一个字母最少需要用一个字节来存储，然后呢，一个字节又由8个2进制位来表示，也就是８bit，所以呢，一个计算机中最小的数据也需要用一个字节来存储噢。那为是什么8位而不是9位、10位、20位呢？这个问题上学的时候应该都讲过，不明白的自己网上查下吧再。8个二进制如何表示60这个数字呢？聪明的计算机先人们想到了用占位的方式来轻松的实现了，怎么占位呢？如下表所示，我们把8个二进制位依次排列，每个二进制位代表一个固定的数字，这个数字是由2的8次方得来的，即每个二进制位代表的值就是2的第几次方的值，８个二进制位能表示的最大数是2**8=256，那把60分解成二进制其实就是以此在这8位上做个比对，只要把其中的几位相加，如果结果正好等于60，那这个位就找对了，首先看60 肯定占不了128和64那两位，不占位就设为0，后面的32+16+8+4=60，所以这几位要设置为1，其它的全设置为0，13的二进制算法也是一样的。

二进制位数	8	7	6	5	4	3	2	1
每位所代表的数字	128	64	32	16	8	4	2	1
60	0	0	1	1	1	1	0	0
13	0	0	0	0	1	1	0	1

　　如果进行2个10进制数字的位运算

运算符	描述	示例
&	与运算，这个二进制位必须在2组数中都为真，结果才返回真	(a & b)得12，二进制位： 0000 1100
\|	或运算，这个二进制位只需在其中一组数据中为真即返回真	(a \| b)得 61，二进制位： 0011 1101
^	异或运算，只要这个二进制位在两组数据中不相同就返回真	(a ^ b)得 49 ，二进制位： 0011 0001
<<	左移运算，将a整体向左移2位	a << 2得240，二进制位： 1111 0000
>>	右移运算，将a整体向左移3位	a >> 3得 7 ，二进制位： 0000 0111

　　看下面的运算过程：

二进制位	8	7	6	5	4	3	2	1	结果
每位所代表的数字	128	64	32	16	8	4	2	1
60	0	0	1	1	1	1	0	0
13	0	0	0	0	1	1	0	1
&与运算	0	0	0	0	1	1	0	0	12
\|或运算	0	0	1	1	1	1	0	1	61
^异或运算	0	0	1	1	0	0	0	1	49
a<<2	1	1	1	1	0	0	0	0	240
a>>3	0	0	0	0	0	1	1	1	7

　　逻辑运算符 and 、or 、not

　　关系运算符 in 、not in

　　验证运算符 is 、 is not

三、字符串类型

字符串(str)

字符串类型是python的序列类型，他的本质就是字符序列，而且python的字符串类型是不可以改变的，你无法将原字符串进行修改，但是可以将字符串的一部分复制到新的字符串中，来达到相同的修改效果。

创建字符串类型可以使用单引号或者双引号又或者三引号来创建，实例如下：

单引号

>>> string = 'ansheng'
# type是查看一个变量的数据类型
>>> type(string)
<class 'str'>

双引号

>>> string = "ansheng"
# type是查看一个变量的数据类型
>>> type(string) 
<class 'str'>

三引号

>>> string = """ansheng"""
>>> type(string)
<class 'str'>

还可以指定类型

>>> var=str("string")
>>> var
'string'
>>> type(var)
<class 'str'>

字符串方法

每个类的方法其实都是很多的，无论我们在学习的过程中个还是工作的时候，常用的其实没有多少，所以我们没必要去可以得记那么多，有些方法我们只需要对其有个印象就ok了，忘了的时候可以google一下。

首字母变大写

capitalize(self):

>>> name="ansheng"
>>> name.capitalize()
'Ansheng'

内容居中，width：字符串的总宽度；fillchar：填充字符，默认填充字符为空格。

center(self, width, fillchar=None):

# 定义一个字符串变量，名为"string"，内容为"hello word"
>>> string="hello word"
# 输出这个字符串的长度，用len(value_name)
>>> len(string)
10
# 字符串的总宽度为10，填充的字符为"*"
>>> string.center(10,"*")
'hello word'
# 如果设置字符串的总产都为11，那么减去字符串长度10还剩下一个位置，这个位置就会被*所占用
>>> string.center(11,"*")
'*hello word'
# 是从左到右开始填充
>>> string.center(12,"*")
'*hello word*'

统计字符串里某个字符出现的次数,可选参数为在字符串搜索的开始与结束位置。

count(self, sub, start=None, end=None):

参数	描述
sub	搜索的子字符串;
start	字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0;
end	字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置;

>>> string="hello word"
# 默认搜索出来的"l"是出现过两次的
>>> string.count("l")
2
# 如果指定从第三个位置开始搜索，搜索到第六个位置，"l"则出现过一次
>>> string.count("l",3,6)
1

解码

decode(self, encoding=None, errors=None):

# 定义一个变量内容为中文
temp = "中文"
# 把变量的字符集转化为UTF-8
temp_unicode = temp.decode("utf-8")

编码，针对unicode

encode(self, encoding=None, errors=None):

# 定义一个变量内容为中文,字符集为UTF-8
temp = u"中文"
# 编码，需要指定要转换成什么编码
temp_gbk = temp_unicode.encode("gbk")

于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。

endswith(self, suffix, start=None, end=None):

参数	描述
suffix	后缀，可能是一个字符串，或者也可能是寻找后缀的tuple
start	开始，切片从这里开始
end	结束，片到此为止

>>> string="hello word"
# 判断字符串中是否已"d"结尾，如果是则返回"True"
>>> string.endswith("d")
True
# 判断字符串中是否已"t"结尾，不是则返回"False"
>>> string.endswith("t")
False
# 制定搜索的位置，实则就是从字符串位置1到7来进行判断，如果第七个位置是"d"，则返回True，否则返回False
>>> string.endswith("d",1,7)
False

把字符串中的tab符号(‘\t’)转为空格，tab符号(‘\t’)默认的空格数是8。

expandtabs(self, tabsize=None):

参数	描述
tabsize	指定转换字符串中的 tab 符号(‘\t’)转为空格的字符数

>>> string="hello       word"
# 输出变量"string"内容的时候会发现中间有一个"\t"，这个其实就是一个`tab`键
>>> string
'hello\tword'
# 把`tab`键换成一个空格
>>> string.expandtabs(1)
'hello word'
# 把`tab`键换成十个空格
>>> string.expandtabs(10)
'hello     word'

检测字符串中是否包含子字符串str，如果指定beg(开始)和end(结束)范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

find(self, sub, start=None, end=None):

参数	描述
str	指定检索的字符串
beg	开始索引，默认为0
end	结束索引，默认为字符串的长度

>>> string="hello word"
# 返回`o`在当前字符串中的位置，如果找到第一个`o`之后就不会再继续往下面寻找了
>>> string.find("o")
4
# 从第五个位置开始搜索，返回`o`所在的位置
>>> string.find("o",5)
7

字符串格式，后续文章会提到。

format(*args, **kwargs):

检测字符串中是否包含子字符串 str ，如果指定 beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

index(self, sub, start=None, end=None):

参数	描述
str	指定检索的字符串
beg	开始索引，默认为0
end	结束索引，默认为字符串的长度

>>> string="hello word"
# 返回字符串所在的位置
>>> string.index("o")
4
# 如果查找一个不存在的字符串那么就会报错
>>> string.index("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

法检测字符串是否由字母和数字组成，如果string至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False

isalnum(self):

>>> string="hes2323"
# 如果存在数字或字母就返回`True`，否则返回`False`
>>> string.isalnum()
True
# 中间有空格返回的就是False了
>>> string="hello word"
>>> string.isalnum()
False

检测字符串是否只由字母组成。

isalpha(self):

# 如果全部都是字母就返回`True`
>>> string="helloword"
>>> string.isalpha()
True
# 否则就返回False
>>> string="hes2323"
>>> string.isalpha()
False

检测字符串是否只由数字组成

isdigit(self):

# 如果变量里面都是数字就返回`True`，否则就返回`False`
>>> string="hes2323"
>>> string.isdigit()
False
>>> string="2323"
>>> string.isdigit()
True

检测字符串是否由小写字母组成

islower(self):

# 如果变量内容全部都是小写字母就返回`True`，否则就返回`False`
>>> string="hesasdasd"
>>> string.islower()
True
>>> string="HelloWord"
>>> string.islower()
False

检测字符串是否只由空格组成

isspace(self):

# 如果变量内容由空格来组成，那么就返回`True`否则就返回`False`
>>> string=" "
>>> string.isspace()
True
>>> string="a"
>>> string.isspace()
False

检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

istitle(self):

# 如果变量的内容首字母是大写并且其他字母为小写，那么就返回`True`，否则会返回`False`
>>> string="Hello Word"
>>> string.istitle()
True
>>> string="Hello word"
>>> string.istitle()
False

检测字符串中所有的字母是否都为大写。

isupper(self):

# 如果变量值中所有的字母都是大写就返回`True`，否则就返回`False`
>>> string="hello word"
>>> string.isupper()
False
>>> string="HELLO WORD"
>>> string.isupper()
True

将序列中的元素以指定的字符连接生成一个新的字符串。

join(self, iterable):

>>> string=("a","b","c")
>>> '-'.join(string)
'a-b-c'

返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

ljust(self, width, fillchar=None):

参数	描述
width	指定字符串长度
fillchar	填充字符，默认为空格

>>> string="helo word"
>>> len(string)
9
# 定义的长度减去字符串的长度,剩下的就开始填充
>>> string.ljust(15,'*')
'helo word******'

转换字符串中所有大写字符为小写。

lower(self):

# 把变量里的大写全部转换成小写
>>> string="Hello WORD"
>>> string.lower()
'hello word'

截掉字符串左边的空格或指定字符

lstrip(self, chars=None):

参数	描述
chars	指定截取的字符

# 从左侧开始删除匹配的字符串
>>> string="hello word"
>>> string.lstrip("hello ")
'word'

用来根据指定的分隔符将字符串进行分割，如果字符串包含指定的分隔符，则返回一个3元的tuple，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

partition(self, sep):

参数	描述
str	指定的分隔符

# 返回的是一个元组类型
>>> string="www.ansheng.me"
>>> string.partition("ansheng")
('www.', 'ansheng', '.me')

把字符串中的 old(旧字符串)替换成new(新字符串)，如果指定第三个参数max，则替换不超过max次

replace(self, old, new, count=None):

参数	描述
old	将被替换的子字符串
new	新字符串，用于替换old子字符串
count	可选字符串, 替换不超过count次

>>> string="www.ansheng.me"
# 把就字符串`www.`换成新字符串`https://`
>>> string.replace("www.","https://")
'https://blog.ansheng.me'
# 就字符串`w`换成新字符串`a`只替换`2`次
>>> string.replace("w","a",2)
'aaw.ansheng.me'

返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

rfind(self, sub, start=None, end=None):

参数	描述
str	查找的字符串
beg	开始查找的位置，默认为0
end	结束查找位置，默认为字符串的长度

>>> string="hello word"
# rfind其实就是反向查找
>>> string.rfind("o")
7
# 指定查找的范围
>>> string.rfind("o",0,6)
4

返回子字符串str在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。

rindex(self, sub, start=None, end=None):

参数	描述
str	查找的字符串
beg	开始查找的位置，默认为0
end	结束查找位置，默认为字符串的长度

>>> string="hello word"
# 反向查找索引
>>> string.rindex("o")
7
# 如果没有查找到就报错
>>> string.rindex("a")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

rjust(self, width, fillchar=None):

参数	描述
width	指定填充指定字符后中字符串的总长度
fillchar	填充的字符，默认为空格

>>> string="hello word"
>>> len(string)
10
>>> string.rjust(10,"*")
'hello word'
>>> string.rjust(12,"*")
'**hello word'

从右到左通过指定分隔符对字符串进行切片,如果参数num有指定值，则仅分隔num个子字符串

rsplit(self, sep=None, maxsplit=None):

参数	描述
str	隔符，默认为空格
num	分割次数

>>> string="www.ansheng.me"
>>> string.rsplit(".",1)
['www.ansheng', 'me']
>>> string.rsplit(".",2)
['www', 'ansheng', 'me']

删除string字符串末尾的指定字符（默认为空格）.

rstrip(self, chars=None):

参数	描述
chars	指定删除的字符

# 从尾部开始匹配删除
>>> string="hello word"
>>> string.rstrip("d")
'hello wor'

从左到右通过指定分隔符对字符串进行切片,如果参数num有指定值，则仅分隔num个子字符串

split(self, sep=None, maxsplit=None):

参数	描述
str	分隔符，默认为空格
num	分割次数

>>> string="www.ansheng.me"
# 指定切一次，以`.`来分割
>>> string.split(".",1)
['www', 'ansheng.me']
# 指定切二次，以`.`来分割
>>> string.split(".",2)
['www', 'ansheng', 'me']

按照行分隔，返回一个包含各行作为元素的列表，如果num指定则仅切片num个行.

splitlines(self, keepends=False):

参数	描述
num	分割行的次数

# 定义一个有换行的变量，`\n`可以划行
>>> string="www\nansheng\nme"
# 输出内容
>>> print(string)
www
ansheng
me
# 把有行的转换成一个列表
>>> string.splitlines(1)
['www\n', 'ansheng\n', 'me']

检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

startswith(self, prefix, start=None, end=None):

参数	描述
str	检测的字符串
strbeg	可选参数用于设置字符串检测的起始位置
strend	可选参数用于设置字符串检测的结束位置

>>> string="www.ansheng.me"
>>> string.startswith("www")
True
>>> string.startswith("www",3)
False

移除字符串头尾指定的字符（默认为空格）

strip(self, chars=None):

参数	描述
chars	移除字符串头尾指定的字符

>>> string=" www.ansheng.me "
>>> string
' www.ansheng.me '
# 删除空格
>>> string.strip()
'www.ansheng.me'
>>> string="_www.ansheng.me_"
# 指定要把左右两边的"_"删除掉
>>> string.strip("_")
'www.ansheng.me'

用于对字符串的大小写字母进行转换，大写变小写，小写变大写

swapcase(self):

>>> string="hello WORD"
>>> string.swapcase()
'HELLO word'

返回”标题化”的字符串,就是说所有单词都是以大写开始，其余字母均为小写。

title(self):

>>> string="hello word"
>>> string.title()
'Hello Word'

根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

translate(self, table, deletechars=None):

参数	描述
table	翻译表，翻译表是通过maketrans方法转换而来
deletechars	字符串中要过滤的字符列表

将字符串中的小写字母转为大写字母

upper(self):

>>> string="hello word"
>>> string.upper()
'HELLO WORD'

返回指定长度的字符串，原字符串右对齐，前面填充0

zfill(self, width):

参数	描述
width	指定字符串的长度。原字符串右对齐，前面填充0

>>> string="hello word"
>>> string.zfill(10)
'hello word'
>>> string.zfill(20)
'0000000000hello word'

str类型和bytes类型转换

以UTF-8编码的时候，一个汉字是三个字节，一个字节是八位

3.5.x实例

代码如下：

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

var = "中文"
for n in var:
    print(n)

print("================")

var2 = "zhongwen"
for n in var2:
    print(n)

执行结果：

C:\Python35\python.exe F:/Python_code/sublime/Day03/str.py
中
文
================
z
h
o
n
g
w
e
n

2.7.x实例

代码如下：

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

var = "中文"
for n in var:
    print(n)

print("================")

var2 = "zhongwen"
for n in var2:
    print(n)

执行结果

C:\Python27\python.exe F:/Python_code/sublime/Day03/str.py
�
�
�
�
�
�
================
z
h
o
n
g
w
e
n

通过上面的实例可以知道，Python3.5.x在输出中文或者英文的时候是按照一个字符一个字符来输出的，但是在Python2.7.x就不这样了，Python2.7.x是按照字节来进行输出的，可以看到在输出中文的时候是乱码的，而且还输出了六次，因为在UTF-8编码的情况下一个汉字是等于三个字节的，所以输出了六个乱码的字符。

在Python3.5.x里面是既可以输出汉字，也可以把输出字节的，利用bytes这个方法，bytes可以将字符串转换为字节

var="中文"
for n in var:
    print(n)
    bytes_list = bytes(n, encoding='utf-8')
    # 十六进制输出
    print(bytes_list)
    for x in bytes_list:
        # 十进制,bin(x)二进制
        print(x,bin(x))

输出的结果

# 字符串
中
# 十六进制
b'\xe4\xb8\xad'
# 228=十进制，0b11100100=二进制
228 0b11100100
184 0b10111000
173 0b10101101
文
b'\xe6\x96\x87'
230 0b11100110
150 0b10010110
135 0b10000111

b代表十六进制，\xe4这样的是一个十六进制的字节

其他知识点

索引

索引是指某个值在列表或别的数据类型中的一个位置

定义一个列表，查看列表中Linux值对应在列表中的位置

>>> list_os = ["Windows","Linux","Mac","Unix"]
>>> list_os.index("Linux")
1
>>> list_os[1]
'Linux'

使用`\`转义

Python允许你对某些字符进行转义，以此来实现一些难以单纯用字符描述的效果

# 常用的内容也转义也就是`\n`和`\t`了，`\n`是用来换行的，`\t`是用来代替一个`tab`键
>>> string="My \n Name  \t is"
>>> print(string)
My
 Name    is

使用`+`拼接

你可以使用+号将多个字符串或字符串变量拼接起来

>>> a="my "
>>> b="name "
>>> c="is "
>>> d="ansheng"
>>> a+b+c+d
'my name is ansheng'

切片

切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的，切片操作符中的第一个数表示切片开始的位置，第二个数表示切片到哪里结束，第三个数表示切片间隔数。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。注意，返回的序列从开始位置开始，刚好在结束位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。

>>> os="Linux"
>>> os
'Linux'
>>> os[0:2]
'Li'
>>> os[0:4:2]
'Ln'

更多实例如下

切片符	说明
[:]	提取从开头到结尾的整个字符串
[start:]	从start到结尾的字符串
[:end]	从开头提取到end - 1
[start:end]	从start提取到end - 1
[start : end : setp]	从start提取到end-1，每setp个字符提取一个

索引和切片同时适用于字符串、列表与元组

索引通常用于查找某一个字符串或值
切片通常用于查找某一个范围内的字符串或值

实例：

# 定义一个列表，列表内有三个元素
>>> var=["Linux","Win","Unix"]
# 通过索引取到了一个值
>>> var[0]
'Linux'
# 通过切片取到了多个值
>>> var[0:2]
['Linux', 'Win']
>>> var[1:3]
['Win', 'Unix']

`四、列表`

创建列表的几种方法

第一种

name_list = ['Python', 'PHP', 'JAVA']

第二种

name_list ＝ list(['Python', 'PHP', 'JAVA'])

创建一个空列表

>>> li = list() 
>>> type(li)
<class 'list'>

把一个字符串转换成一个列表

>>> var="abc"
>>> li = list(var)
>>> li
['a', 'b', 'c']

list在把字符串转换成列表的时候，会把字符串用for循环迭代一下，然后把每个值当作list的一个元素。

把一个元组转换成列表

>>> tup=("a","b","c")
>>> li=list(tup)
>>> type(li)
<class 'list'>
>>> li
['a', 'b', 'c']

把字典转换成列表

>>> dic={"k1":"a","k2":"b","k3":"c"}
>>> li=list(dic)
>>> type(li)
<class 'list'>
>>> li
['k3', 'k1', 'k2']

字典默认循环的时候就是key，所以会把key当作列表的元素

>>> dic={"k1":"a","k2":"b","k3":"c"}
>>> li=list(dic.values())
>>> li
['c', 'a', 'b']

如果指定循环的是values，那么就会把values当作列表的元素

列表所提供的方法

在列表末尾添加新的对象

append(self, p_object):

>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list.append("C#")
>>> name_list
['Python', 'PHP', 'JAVA', 'C#']

统计某个元素在列表中出现的次数

count(self, value):

属性	描述
obj	列表中统计的对象

>>> name_list = ['Python', 'PHP', 'PHP']
>>> name_list.count("PHP")
2

用于在列表末尾一次性追加另一个序列中的多个值

extend(self, iterable):

属性	描述
seq	元素列表

>>> name_list = ['Python', 'PHP', 'Python']
>>> name_OS = ['Windows', 'Linux', 'Unix']
>>> name_list
['Python', 'PHP', 'Python']
>>> name_OS
['Windows', 'Linux', 'Unix']
# 把列表`name_OS`中的内容添加到`name_list`的尾部
>>> name_list.extend(name_OS)
# 输出的结果
>>> name_list
['Python', 'PHP', 'Python', 'Windows', 'Linux', 'Unix']

从列表中找出某个值第一个匹配项的索引位置

index(self, value, start=None, stop=None):

属性	描述
value	列表中统计的对象

# 查找对象所在的位置
>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list.index("PHP")
1

将指定对象插入列表

insert(self, index, p_object):

属性	描述
index	对象obj需要插入的索引位置
obj	要出入列表中的对象

>>> name_list = ['Python', 'PHP', 'JAVA']
# 把位置`1`的内容换成`C`，后面的自动退格一个位置
>>> name_list.insert(1,"C")
>>> name_list
['Python', 'C', 'PHP', 'JAVA']

移除列表中的一个元素，并且返回该元素的值

pop(self, index=None):

属性	描述
index	可选参数，要移除列表元素的位置

>>> name_list = ['Python', 'PHP', 'JAVA']
# 删除位置1上面的内容，并且返回删除的字符串
>>> name_list.pop(1)
'PHP'
>>> name_list
['Python', 'JAVA']

移除列表中某个值的第一个匹配项

remove(self, value):

属性	描述
value	列表中要移除的对象

>>> name_list = ['Python', 'PHP', 'JAVA', 'Python']
# 每次删除的时候只会把第一次匹配到的值删除，第二个值不会被删除
>>> name_list.remove("Python")
>>> name_list
['PHP', 'JAVA', 'Python']
>>> name_list.remove("Python")
>>> name_list
['PHP', 'JAVA']

当然删除元素还可以直接使用del进行删除：

>>> L = [1,2,3]
>>> del L[1]
>>> L
[1, 3]

又或者使用切片赋值进行元素删除

>>> L = [1,2,3]
>>> L[1:2] = []
>>> L
[1, 3]

反向输出列表中的元素

reverse(self):

>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list
['Python', 'PHP', 'JAVA']
>>> name_list.reverse()
>>> name_list
['JAVA', 'PHP', 'Python']

对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数

sort(self, cmp=None, key=None, reverse=False):

>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list
['Python', 'PHP', 'JAVA']
>>> name_list.sort()
>>> name_list
['JAVA', 'PHP', 'Python']

清除列表内所有元素

>>> li
['Ansheng']
>>> li.clear()
>>> li
[]

同字符串一样，列表也支持解析，称为列表解析

>>> li = [x for x in range(1,20)]
>>> li
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

`五、字典`

字典(dict)在基本的数据类型中使用频率也是相当高的，而且它的访问方式是通过键来获取到对应的值，当然存储的方式也是键值对了，属于可变类型。

创建字典的两种方式

第一种

>>> dic = {"k1":"123","k2":"456"}
>>> dic
{'k1': '123', 'k2': '456'}
>>> type(dic)
<class 'dict'>

第二种

>>> dic = dict({"k1":"123","k2":"456"})
>>> dic
{'k1': '123', 'k2': '456'}
>>> type(dic)
<class 'dict'>

在创建字典的时候，__init__初始化的时候还可以接受一个可迭代的变量作为值

>>> li = ["a","b","c"]
>>> dic = dict(enumerate(li))
>>> dic
{0: 'a', 1: 'b', 2: 'c'}

默认dict再添加元素的时候会把li列表中的元素for循环一边，添加的时候列表中的内容是字典的值，而键默认是没有的，可以通过enumerate方法给他加一个序列，也就是键。

与其变量不同的是，字典的键不仅仅支持字符串，而且还支持其他数据类型，譬如：

# 数字
>>> D = {1:3}
>>> D[1]
3
# 元组
>>> D = {(1,2,3):3}
>>> D[(1,2,3)]
3

字典解析

>>> D = {x: x*2 for x in range(10)}
>>> D
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
# 可以使用zip
>>> D = {k:v for (k, v) in zip(['a','b','c'],[1,2,3])}
>>> D
{'a': 1, 'c': 3, 'b': 2}

字典所提供的常用方法

删除字典中的所有元素

clear(self):

>>> person = dict({"name": "ansheng", 'age': 18})
>>> person
{'age': 18, 'name': 'ansheng'}
>>> person.clear()
# 清空字典的内容之后字典会变成一个空字典
>>> person
{}

返回一个字典的浅复制

copy(self):

>>> person = dict({"name": "ansheng", 'age': 18})
>>> person.copy()
{'age': 18, 'name': 'ansheng'}

创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

fromkeys(S, v=None):

属性	描述
S	字典键值列表
v	可选参数, 设置键序列（seq）的值

>>> seq = ('name', 'age', 'sex')
>>> dict = dict.fromkeys(seq)
>>> dict
{'age': None, 'name': None, 'sex': None}

fromkeys方法就是把一个字典的key更新到另外一个字典中，默认的值可以设置

>>> dic={"k1":123,"k2":456,"k4":111}
>>> dic
{'k1': 123, 'k4': 111, 'k2': 456}
# 创建一个新的字典，默认值是`123`
>>> dic.fromkeys(["k1","k2","k3"],"123")
{'k1': '123', 'k3': '123', 'k2': '123'}

返回指定键的值，如果值不在字典中返回默认值

get(self, k, d=None):

属性	描述
key	字典中要查找的键
default	如果指定键的值不存在时，返回该默认值值

>>> person = {"name": "ansheng", 'age': 18}
>>> person.get("name")
'ansheng'

成员运算符in可以判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false

>>> person = {"name": "mr", 'age': 18}
>>> 'name' in person
True
>>> 'aname' in person
False

以列表返回可遍历的(键, 值)元组数组

items(self):

>>> person = {"name": "mr.wu", 'age': 18}
# 以元组的方式输出出来
>>> person.items()
[('age', 18), ('name', 'mr.wu')]

以列表的形式返回一个字典所有的键

keys(self):

>>> person = {"name": "ansheng", 'age': 18}
>>> person.keys()
['age', 'name']

删除指定给定键所对应的值，返回这个值并从字典中把它移除

pop(self, k, d=None):

>>> person = {"name": "ansheng", 'age': 18}
>>> person
{'age': 18, 'name': 'ansheng'}
# 返回删除键对应的值
>>> person.pop("age")
18
>>> person
{'name': 'ansheng'}

随机返回并删除字典中的一对键和值，因为字典是无序的，没有所谓的”最后一项”或是其它顺序。

popitem(self):

>>> person = {"name": "ansheng", 'age': 18}
# 随即删除并显示所删除的键和值
>>> person.popitem()
('age', 18)
>>> person
{'name': 'ansheng'}

如果key不存在，则创建，如果存在，则返回已存在的值且不修改

setdefault(self, k, d=None):

属性	描述
key	查找的键值
default	键不存在时，设置的默认键值

>>> person = {"name": "ansheng", 'age': 18}
# 如果字典中有这个键，那么就输出这个键的值
>>> person.setdefault("name")
'ansheng'
# 如果没有则不输出，但是会创建一个键，值为默认的'None'，值是可以指定的
>>> person.setdefault("sex")
>>> person
{'age': 18, 'name': 'ansheng', 'sex': None}

把字典dic2的键/值对更新到dic1里

update(self, E=None, **F):

>>> dic1 = {"name":"ansheng"}
>>> dic2 = {"age":"18"}
>>> dic1
{'name': 'ansheng'}
>>> dic2
{'age': '18'}
>>> dic1.update(dic2)
>>> dic1
{'age': '18', 'name': 'ansheng'}

显示字典中所有的值

values(self):

>>> person = {"name": "ansheng", 'age': 18}
>>> person.values()
[18, 'ansheng']

六、元组

元组(tuple)和列表的为唯一区别就是列表可以更改，元组不可以更改，其他功能与列表一样

创建元组的两种方法

第一种

ages = (11, 22, 33, 44, 55)

第二种

ages = tuple((11, 22, 33, 44, 55))

如果元祖内只有一个元素，那么需要加上一个逗号，否则就变成字符串了。

In [1]: t = (1)

In [2]: t
Out[2]: 1

In [3]: type(t)
Out[3]: int

In [4]: t = (1,)

In [5]: t
Out[5]: (1,)

In [6]: type(t)
Out[6]: tuple

元组所具备的方法

查看列表中元素出现的次数

count(self, value):

属性	描述
value	元素的值

>>> ages = tuple((11, 22, 33, 44, 55))
>>> ages
(11, 22, 33, 44, 55)
>>> ages.count(11)
1

查找元素在元组中的位置