python基础篇{数据类型}

 python基础学习路线：

   · 数据分析之python基础篇{基础语法}
   · 数据分析之python基础篇{数据类型}
   · 数据分析之python基础篇{控制流语句}
   · 数据分析之python基础篇{函数}
   · 数据分析之python基础篇{模块}
   · 数据分析之python基础篇{文件操作}
   · 数据分析之python基础篇{Pymysql}
   · 数据分析之python基础篇{面向对象}

  这里主要是写python常用的基础知识，不会面面俱到，这里介绍一个网站菜鸟教程可以帮助同学们迅速打好基础

  Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

  Python3 的六个标准数据类型中
  不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

数字类型

  python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 布尔数据类型就是我们常说的真和假，只有两个值构成，True和False。

3 > 4  #结果为fasle
4 > 3  #结果为Ture

• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

  Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
  等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。也就是说，是右边的值赋值给我左边的变量。

a = 1
b = 1.1
c = ture
d = 4+3j

 python支持多个变量赋值

a = b = c = 1
type(a) #查看数据类型

	运行结果：int

#或者
 a, b, c, d = 20, 5.5, True, 4+3j

 数字类型的转换

int(8.7)
float(8)
int("1")

	运行结果：8
	         8.0
	         1

 数字的计算

  以a = 10 ，b = 20为例
下面以a=10 ,b=20为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	x除以y b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000

a = 10
b = 20
a + b
a - b
a % b

	运行结果：30
	         -10
	         20

   运算的优先级：加减大于乘除 指数运算大于乘除

 math科学计算库

	python内置的一些计算函数：
abs(x)	返回x的绝对值，类型随x
max(n1, n2, …)	返回最大值
min(n1, n2, …)	返回最小值
round(x [,n])	默认返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的n位。例如round(1.23456, 3)返回1.235

max(2,1,4,3)
min(2,1,4,3)

	运行结果：4
			 1

	python还提供科学计算等库，例如math，导入math库后，常用的函数有：
fabs(x)	返回x的绝对值，类型是浮点数
ceil(x)	取x的上入整数，如math.ceil(4.1)返回5
floor(x)	取x的下入整数，如math.floor(4.9)返回4
exp(x)	返回e的x次幂，e是自然常数
sqrt(x)	返回x的平方根，返回值是float类型
modf(x)	返回x的整数部分和小数部分，两部分的符号与x相同，整数部分以浮点型表示。例如math.modf(4.333)，返回元组(0.3330000000000002, 4.0)
log10(x)	返回以10为基数的x的对数，返回值类型是浮点数
log(x,y)	返回以y为基数的x的对数，返回值类型是浮点数
pow(x, y)	返回x的y次幂，即x**y

import math #先导入math包
x = 3
math.exp(x)
math.log10(x)

 复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	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

 python中的比较运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.

a = 3
b = 4
a == b

	运行结构：False

 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

练习题

  练习一：一个苹果的价格是10元, 一个梨的价格是12元, 如果买6个苹果, 三个梨, 需缴纳交易税为22%, 总共需要花费多少钱?

apple= 10
pear = 12
AppleNumber = 6
PearNmuber =  3
money  = float((apple*AppleNumber + pear*PearNmuber + ((apple*AppleNumber + pear*PearNmuber) * 0.22))

	运行结果：117.12

  练习二: 计算根号5加上17的平方的结果取10的对数的
$${\log }_{10}(\sqrt{5}+17^2)$$

import math
math.log10(math.sqrt(5)+math.pow(17,2))

	运行结果：2.464245158943211

  练习三：用普通运算符和复合运算符分别计算以下问题：有一个数字，数字的值为12，让这个数字在原有的基础上减去2，求减去后的结果是多少。

a = 12
a -= 2 #等价于 a = a - 2

	运行结果：10

字符串

  字符串是指以""双引号, 或者''单引号括起来的任意文本, 例如"abaa",'1232’凡是在引号中的都是字符串

s = "你好"
s1 = "abcd"
s2 = "3456341"

 使用三引号('''或""")可以指定一个多行字符串。

  即当字符串比较长，一行写不下，需要换行的时候，可以使用长字符串

s_length = """知而不行，谓之不诚。 
行而不成，谓之不能。 
知而行，是赤诚之心，行而能，是贯彻到底，已经很难被其他人和事影响了。 
而知行合一的前提是，格物致知，将一件事研究到极致，变成自己的知识。 
比如做菜，将做菜这门手艺做到尽善尽美，色香味无可挑剔；比如建筑，将楼宇亭台建得坚固美观使用，美轮美奂，风雨不倒地震不塌；比如造船，将造船原理吃透，用料坚固，风浪不沉。 
这便是格物致知，将一件东西一件事情研究到极点，明白其中所有的道理。 
做到格物致知，方能知行合一。
"""

	运行结果：知而不行，谓之不诚。 
			 行而不成，谓之不能。 
             知而行，是赤诚之心，行而能，是贯彻到底，已经很难被其他人和事影响了。 
             而知行合一的前提是，格物致知，将一件事研究到极致，变成自己的知识。 
             比如做菜，将做菜这门手艺做到尽善尽美，色香味无可挑剔；比如建筑，将楼宇亭台建得坚固美观使用，美轮美奂，风雨不倒地震不塌；比如造船，将造船原理吃透，用料坚固，风浪不沉。 
             这便是格物致知，将一件东西一件事情研究到极点，明白其中所有的道理。 
             做到格物致知，方能知行合一。

 当字符串本身内容中包含有引号时，可能会引起引号冲突

s5 = "Rose:"You jump,I jump!"" # 类似于此，程序就会报错

  对于这种冲突，可以使用转义符号\，对该符号进行转义

s9 = "Rose:\"You jump,I jump!\"" # 程序就不会报错

  但是如果引号不相同则不会

s6 = '王小波："你好哇，李银河！".'
# 英文的"和中文的”
s7 = "王小波：“你好哇，李银河！”." 
s8 = "王小波：'你好哇，李银河！'."

 字符串的拼接和重复

  字符串使用 + 相当于拼接两个字符串
  字符串 * n , 相当于把字符串重复n次

"梅西" + "C罗"
"梅西"*10
"梅西 "*10

	运行结果：'梅西C罗'
         	 '梅西梅西梅西梅西梅西梅西梅西梅西梅西梅西'
	         '梅西 梅西 梅西 梅西 梅西 梅西 梅西 梅西 梅西 梅西 '

 字符串的索引和切片

  字符串也是一个可迭代对象, 也就是说每一个字符串实际上都有一个对应的索引值。索引值从零开始计算，每一个字符对应一个唯一的索引值。索引值也可以从后往前算，后面从负一开始计算。

test = "零一二三四五六七八九"
test[0]
test[-1]

	运行结果：零
             九

 	思考问题：有的时候我不仅仅想取出字符串的其中一个字符,想要取出其中一部分,这时候应该怎么做呢?

  字符串切片的标准语法:string[开始位置:终止位置:步长和方向]

  注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。

test = "零一二三四五六七八九"
test[5:]
test[:5]
test[8:5:-1] #如果从后向前切，那么开始位置也是后面
test[-2:-5:-1]

	运行结果：'五六七八九'
	'零一二三四'
	'八七六'
	'八七六

练习题

  练习一：有一个字符串，按照要求切除内容practice = “有些人总是这么不一样，看了一眼，就能让人记住很多年。而有些人，哪怕看了再多年，也没在心头住下。”

在字符串中切片出以下字符

• 有些人
• 这么不一样
• 心头住下
• 下住头心
• 哪看再年
• 下心也

test = "有些人总是这么不一样，看了一眼，就能让人记住很多年。而有些人，哪怕看了再多年，也没在心头住下。"
print(test)
test[0:3]
test[5:10]
test[-6:-2]
test[-2:-6:-1]
test[31:38:2]
test[-2:-9:-3]

  练习三： 给定一个字符串aStr, 请反转字符串

aStr = "abcdefg"
aStr[::-1]

	运行结果：'gfedcba'

  转义字符

  转义字符有很多,这里介绍几个常见的：转义字符

转义字符
\n	表示换行
\t	表示制表符
\\	转义反斜杠
\"	把引号转义成普通字符串

"\"ABC\""
'\'ABC\nbb'

	运行结果：ABC
	         'ABC\nbb

  Python中也可以用r''这种语法创建原生字符串,原生字符串中的字符串不进行转义

r'\'ABC\nbb' 

	运行结果:\'ABC\nbb

 字符串方法

  <1> find
  检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

mystr.find(str, start=0, end=len(mystr))

s_find = "abcdefgabc"
s_find.find('a')
s_find.find('f')

	运行结果：0 
	 		 5

  <2> count

  返回 str在start和end之间 在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))

s_test = """御剑乘风来，除魔天地间，
有酒乐逍遥，无酒我亦颠，
一饮尽江河，再饮吞日月，
千杯醉不倒，唯我酒剑仙。"""
s_test.count('剑')

	运行结果：2

  <3> replace

  把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

mystr.replace(str1, str2, mystr.count(str1))

s10 = """桃花坞里桃花庵，桃花庵里桃花仙；桃花仙人种桃树，又摘桃花换酒钱。
酒醒只在花前坐，酒醉还来花下眠；半醒半醉日复日，花落花开年复年。
但愿老死花酒间，不愿鞠躬车马前；车尘马足贵者趣，酒盏花枝贫者缘。
若将富贵比贫贱，一在平地一在天；若将贫贱比车马，他得驱驰我得闲。
世人笑我太疯癫，我笑世人看不穿；不见五陵豪杰墓，无花无酒锄作田。"""
s10.replace('桃花',"菊花")
print(s10.replace('桃花',"菊花"))

	运行结果：菊花坞里菊花庵，菊花庵里菊花仙；菊花仙人种桃树，又摘菊花换酒钱。
	         酒醒只在花前坐，酒醉还来花下眠；半醒半醉日复日，花落花开年复年。
	         但愿老死花酒间，不愿鞠躬车马前；车尘马足贵者趣，酒盏花枝贫者缘。
	         若将富贵比贫贱，一在平地一在天；若将贫贱比车马，他得驱驰我得闲。
	         世人笑我太疯癫，我笑世人看不穿；不见五陵豪杰墓，无花无酒锄作田。

  <4> split
  以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅 分隔 maxsplit 个子字符串

mystr.split(str=" ", 2)

s11 = 'Forget the memories, continue to be life, miss, just pass by.'
s11.split(' ')
s11.split(',')

	篇幅有限，同学们自行到Pycharm上运行

  <5> splitlines

  按照行分隔，返回一个包含各行作为元素的列表

mystr.splitlines()

split_test = """When you are old and grey and full of sleep,
And nodding by the fire，take down this book,
And slowly read,and dream of the soft look 
Your eyes had once,and of their shadows deep; 
How many loved your moments of glad grace, 
And loved your beauty with love false or true,
But one man loved the pilgrim Soul in you
And loved the sorrows of your changing face;
And bending down beside the glowing bars,
Murmur,a little sadly,how Love fled
And paced upon the mountains overhead
And hid his face amid a crowd of stars."""
split_test.splitlines()

	篇幅有限，同学们自行到Pycharm上运行

  <6> lower和upper

• lower 转换 mystr 中所有大写字符为小写

mystr.lower()

• upper 转换 mystr 中的小写字母为大写

mystr.upper()

a = "ADFEdifeiASF"
a.lower()
'sdfsdfefsf'.upper()

	运行结果：'adfedifeiasf'
	         'SDFSDFEFSF'

练习题

  练习一：查找出“上”字的索引值，并利用切片提取出上及后面的两个字

s_test = """仗剑红尘已是癫，有酒平步上青天。
游星戏斗弄日月，醉卧云端笑人间。"""
s_test.find('上')
s_test[12:12+3]
  # 代码优化
  # 运行结果一样
s_test[s_test.find('上'):s_test.find('上')+3]

  练习二：统计出桃花诗中桃花一共出现多少次？然后把桃花诗中的标点符号都换成英文标点符号

s_test = """桃花坞里桃花庵，桃花庵里桃花仙；桃花仙人种桃树，又摘桃花换酒钱。
酒醒只在花前坐，酒醉还来花下眠；半醒半醉日复日，花落花开年复年。
但愿老死花酒间，不愿鞠躬车马前；车尘马足贵者趣，酒盏花枝贫者缘。
若将富贵比贫贱，一在平地一在天；若将贫贱比车马，他得驱驰我得闲。
世人笑我太疯癫，我笑世人看不穿；不见五陵豪杰墓，无花无酒锄作田。"""
s_test.count('桃花')
 s_test.replace('，',',').replace('。','.').replace('；',';')
print(s_test1)

	运行结果：桃花坞里桃花庵,桃花庵里桃花仙;桃花仙人种桃树,又摘桃花换酒钱.  
	         酒醒只在花前坐,酒醉还来花下眠;半醒半醉日复日,花落花开年复年.
	         但愿老死花酒间,不愿鞠躬车马前;车尘马足贵者趣,酒盏花枝贫者缘.
	         若将富贵比贫贱,一在平地一在天;若将贫贱比车马,他得驱驰我得闲.
	         世人笑我太疯癫,我笑世人看不穿;不见五陵豪杰墓,无花无酒锄作田.

  练习三：分割字符串

• 使用空格进行分割,使用逗号进行字符串分割.、
• 使用换行符分割

prictice = """Never mind, I'll find someone like you
I wish nothing but the best for you, too
Don't forget me, I beg, I remember you said
Sometimes it lasts in love, but sometimes it hurts instead
Sometimes it lasts in love, but sometimes it hurts instead
You know how the time flies
Only yesterday was the time of our lives"""
prictice.split(' ')
prictice.split(',')
prictice.splitlines()[0]

	篇幅有限，同学们自行到Pycharm上运行

  练习四：将下列字符串s中的奇数位都转化味大写，偶数位都转换成小写

s = 'sadINDUionaREwSS'
# 定义一个空的字符串用于接收转换结果
s_new = ''
n = 0
for i in s:
    if n % 2 == 0:
        s_new += i.lower()
    else:
        s_new += i.upper()
    n += 1 

	运行结果：'sAdInDuIoNaReWsS'

  字符串还有其他的方法：字符串方法

  字符串的格式化

  Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

  python格式化，有两个方法： % 方法和format方法

# %s方法
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
string=123 
print("string=%s" % string)#打印输出为字符串
num=14.1 
print("num=%d" % num)#输出为整形
import math  
#%a.bf，a表示浮点数的打印长度，b表示浮点数小数点后面的精度  
#只是%f时表示原值，默认是小数点后6位数  
print("PI=%f" % math.pi)

python字符串格式化符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

#format方法
url = 'www.{}.com' ##大括号，代表一个占位符
url.format('cda') 
url = "{}.{}.com"
url.format('map','baidu')

	运行结果：'www.cda.com'
	         'map.baidu.com'

a = "美丽的"
b = "你在哪里"
"你好吗, {}张小姐{}".format(a,b)# 位置进行填充
"你好吗, {1}张小姐{0}".format(b,a ) # 利用数字标识进行填充 
"你好吗, {形容词}张小姐{问她在哪}".format(形容词=a,问她在哪=b )
"{0}就是一个大城市{1}".format("开封","的表率")
"{0}就是一个大城市{1}, {0}房价很贵, {0}是一个古城".format("郑州","的代表")
"{城市}就是一个大城市{描述}, {城市}房价很贵, {城市}是一个古城".format(城市="郑州",描述="的代表")

	运行结果：'你好吗, 美丽的张小姐你在哪里'
	         '你好吗, 美丽的张小姐你在哪里'
	         '你好吗, 美丽的张小姐你在哪里'
	         '开封就是一个大城市的表率'
	         '郑州就是一个大城市的代表, 郑州房价很贵, 郑州是一个古城'
	         '郑州就是一个大城市的代表, 郑州房价很贵, 郑州是一个古城'

列表

  List（列表） 是 Python 中使用最频繁的数据类型。
  列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
  列表用[ ] 标识，是 python 最通用的复合数据类型。创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
s2 = ['临','兵','斗','者','皆','列','阵','在','前']
list3 = ["a", "b", "c", "d"]

  列表中的元素,没有数据类型的限制,可以为任何数据类型

list1 = [1, 2, 3,'on','go',True,False,None]

  与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
  列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

  list是一种有序的集合，可以随时添加和删除其中的元素。

  也就是说列表是内部元素可变的一个容器mutable

  列表和字符串一样,是一种可迭代对象.

 和字符串一样进行索引和切片

  语法方面是一样的.

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表，生成新的列表

	运行结果：['runoob', 786, 2.23, 'john', 70.2]
	         runoob
	         [786, 2.23]
	         [2.23, 'john', 70.2]
	         [123, 'john', 123, 'john']
	         ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]
L[0]
L[1]
L[0][0]
L[1][2]

	运行结果：['Apple', 'Google', 'Microsoft']
	         ['Java', 'Python', 'Ruby', 'PHP']
	         'Apple'
	         'Ruby'

列表的增删改查

 修改列表的元素值

  通过元素的 索引位置来索引元素

L = ['python',
     'java',
     'C',
     'PHP']
L[0] = 'R'
L[2:] = 'C++','pp'

	运行结果：['R', 'java', 'C++', 'JavaScript']
	         ['R', 'java', 'C++', 'pp']

 添加元素

  使用append()方法来添加列表项

L = ['Superman','Hulk','Spiderman']
L.append('Leifengxia')
L

	运行结果：['Superman', 'Hulk', 'Spiderman', 'Leifengxia']

list = []          ## 空列表
list.append('Google')   ## 使用 append() 添加元素
list.append('Runoob')
print list

	运行结果：['Google', 'Runoob']

  通过extend()可以将另一个集合中的元素逐一添加到列表中

a = [1,2]
b = [3,4]
a.append(b)

	运行结果：[1, 2, [3, 4]]

a = [1,2]
b = [3,4]
a.extend(b)

	运行结果：[1, 2, 3, 4]

  insert（index, object) 在指定位置index前插入元素object

a = ['插','入','素']
a.insert( 2,'元')

	运行结果：['插', '入', '元', '素']

 查找元素

• in和not in 判断是否在列表内
• index 查找字段是否在列表内，没有会报错
• count 计算在列表中的出现次数

test = ['插', '入', '元', '素']
'入' in test
'元' not in test
test.index('入')
test1 = ['插', '入', '元', '素','元']
test1.count('元')

	运行结果：True
	         False
	         1
	         2

 删除元素

• del：根据下标进行删除
• pop：删除最后一个元素
• remove：根据元素的值进行删除

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName.pop() #弹出 能够获取到数据

	运行结果：['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人']

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName.pop() #弹出 能够获取到数据
name = movieName.pop() #默认弹出最后一个
name = movieName.pop(1)

	运行结果：'霍比特人'
	         '骇客帝国'

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName.remove('骇客帝国') #根据内容来删除

	运行结果：['加勒比海盗', '第一滴血', '指环王', '霍比特人', '速度与激情']

list1 = ['physics', 'chemistry', 1997, 2000]
 
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1

	运行结果：['physics', 'chemistry', 1997, 2000] 
	         After deleting value at index 2 :
	         ['physics', 'chemistry', 2000]

对元素排序

  排序(sort, reverse)，sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。reverse方法是将list逆置。

a = [1, 4, 2, 3]
a.sort()

	运行结果：[1, 2, 3, 4]

a = [1, 4, 2, 3]
a.sort(reverse=True)

	运行结果：[4, 3, 2, 1]

a = [1, 4, 2, 3]
a.reverse()

	运行结果：[3, 2, 4, 1]

练习题

  练习一：使用for循环,把随机生成的数字一次添加到列表中去

#生存一个1-100的列表
#先定义一个
E = []
for i in range(1,101): # ange随机函数，随机生成范围内的数
    E.append(i)
E

  练习二：使用for循环把列表中的元素拼接成字符串,使用逗号分隔

names = ['raymond', 'rachel', 'matthew', 'roger',
         'betty', 'melissa', 'judith', 'charlie']
# 空字符串用于拼接
s = ''
k = 0
for i in names:
    s += i
    # 在拼接一个逗号
    if k != 7:
        s += '，'
    else:
        s +='。'
    k += 1
print(s)

  练习三：分别打印出字符串的索引值和字符串本身

colors = ['red', 'green', 'blue', 'yellow']
n = 0
for i in colors:
    print(n, "--->", colors[n])
    n+=1
#或者
for i in range(len(colors)):
    print(i , "---->", colors[i])
#或者
for i, color in enumerate(colors):  # 枚举，将索引和数据打包成一个元组对
    print(i, "---->", color)

  练习四：有以下列表

L = ['最怕空气突然安静','最怕朋友突然的关心','最怕回忆','突然翻滚绞痛着','不平息','最怕忽然','听到你的消息']

M = ['想念如果会有声音','不愿那是悲伤的哭泣','终于让自己属于','我自己']

1. 将M列表中的歌词合并到L中,使歌词串联在一起.

2. 在列表中插入缺少的一句歌词,使顺序连续.

3. 查找列表中是否含有元素"最怕回忆"

4. 删除列表中的"最怕回忆"

5. 将歌词拼接成一个字符串,使用join方法

6. 将歌词翻转

L = ['最怕空气突然安静','最怕朋友突然的关心','最怕回忆','突然翻滚绞痛着','不平息','最怕忽然','听到你的消息']
M = ['想念如果会有声音','不愿那是悲伤的哭泣','终于让自己属于','我自己']
L.extend(M)
L.insert(-2,'事到如今')
L.index('最怕回忆')
L.reverse()
L.remove('最怕回忆') # 或者 del L[2]

L = ['最怕空气突然安静','最怕朋友突然的关心','最怕回忆','突然翻滚绞痛着','不平息','最怕忽然','听到你的消息']
M = ['想念如果会有声音','不愿那是悲伤的哭泣','终于让自己属于','我自己']
# 空字符串用于拼接
s = ''
k = 1
for i in L:
    s += i
    # 在拼接一个逗号
    if k != 12:
        s += '，'
    else:
        s +='。'
    k += 1
print(s)
# 或者使用Join方法
','.join(L)

元组

  Python的元组与列表类似，不同之处在于元组的元素不能修改。也就是说元组不能二次赋值，相当于只读列表,元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ("a", "b", "c", "d")

  元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

  元组的元素不能修改

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

  但是，如果我这样写呢

aTuple = ('et',77,99.9,'OK')
aTuple = aTuple[:2]  # 其实是因为aTuple被重新定义了

	运行结果：('et', 77)

#同理
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

  此外，元组内可以含有列表，元组内的列表可以遵循列表的方法。

tuple = ('a', 'b', ['A', 'B'])
print(tuple)
tuple[2][0] = "x"
print(tuple)

	运行结果：('a', 'b', ['A', 'B'])
	         ('a', 'b', ['x', 'B'])

  表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

	运行结果：('runoob', 786, 2.23, 'john', 70.2)
	         runoob
	         (786, 2.23)
	         (2.23, 'john', 70.2)
	         (123, 'john', 123, 'john')
	         ('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

 查找元素

  元组的查找方法，只有

• index 查找字段是否在列表内，没有会报错
• count 计算在列表中的出现次数

tp5 = ('a', 'b', ['A', 'B'])
tp5.count('a')
tp5.index('a')

	运行结果：1
	         0

 删除元组

  元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup = ('physics', 'chemistry', 1997, 2000)
 
print tup
del tup
print "After deleting tup : "
print tup

 元组内置函数

函数	描述
cmp(tuple1, tuple2)	比较两个元组元素。
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(seq)	将列表转换为元组。

  使用方法，详见元组内值函数

字典

  字典是另一种可变容器模型，且可存储任意类型对象。使用键-值（key-value）存储，用冒号分割，具有极快的查找速度。每个键值对之间用逗号分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

  注意： 每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。 键一般是唯一的，一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：值不需要唯一。值可以取任何数据类型，但键必须是不可变的， 正因为数值，布尔，字符串，元组都是不可变的，所以都可以作为字典的key，但是列表不可以。

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, 
     '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90,'拉莫斯':11}

	运行结果：{'C罗纳尔多': 94, '梅西': 93,'内马尔': 92, '苏亚雷斯': 92,'诺伊尔':  '莱万多夫斯基': 91, '拉莫斯': 11}

  如果用dict实现，只需要一个“名字”-“评分”的对照表，直接根据名字查找评分，无论这个表有多大，查找速度都不会变慢。比如：

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, 
     '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}

  我们平时使用字典的时候, 是在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

  dict就是这种实现方式，给定一个名字，比如’梅西’，dict在内部就可以直接计算出梅西对应的存放评分的“页码”，也就是93这个数字存放的内存地址，直接取出来，速度非常快。

 查找字典

  字典是无序的，所以不存在数值索引，需要用Key值来查找对应的value。

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, 
     '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
d['拉莫斯']

  d.keys()——获取字典key

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
d.keys() # 进返回key值
list(d.keys()) # 将key值变成列表

	返回结果：dict_keys(['C罗纳尔多', '内马尔', '拉莫斯', '李毅', '梅西', '苏亚雷斯', '莱万多夫斯基', '诺伊尔'])
      	     ['C罗纳尔多', '内马尔', '拉莫斯', '李毅', '梅西', '苏亚雷斯', '莱万多夫斯基', '诺伊尔']

  d.values()——获取字典values

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
d.values() # 进返回key值
list(d.values()) # 将key值变成列表

  d.items()——打包成元组

在d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
d.items() # 打包成元组

 添加和修改字典

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加
 
print("dict['Age']: ", dict['Age'])
print(dict)

	运行结果：dict['Age']:  8
	         {'Name': 'Zara', 'Age': 8, 'Class': 'First', 'School': 'RUNOOB'}

 删除字典
   d.pop('key') ——必须要传值，因为字典是无序的

# d.pop('key') 
d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
d.pop('内马尔')  # 删除成功
d.pop('科比')  # 程序会报错
d.pop('科比','查找此人不存在')  # 不会报错，会返回结果为查找此人不存在

   d.popitem()—— 随机删除一个

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91, '诺伊尔':92}
d.popitem() # 随机删除
print(d.popitem()) # 返回随机删除的值
print(d) # 返回随机删除后的字典

   del d['key']

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91, '诺伊尔':92}
del d['诺伊尔'] # 删除key值为诺伊尔

   d.clear() 清空字典

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91, '诺伊尔':92}
d.clear() # 删除字典

 判断key是否存在

  可以通过 in判断key是否存在

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,
 '诺伊尔':92}
'李毅' in d ## 返回值为ture
'科比'  in d # 返回值为false
'科比' not in d # 返回值为ture

  通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
d.get('梅西') # 返回90
d.get('卡恩')  # 返回none
d.get('科比', -1) # 返回-1
# 查看
if d.get('科比', -1) == -1:
    print("查找此人不存在")
else:
    print("存在")
## 返回结果为：查找此人不存在
d.get('科比', '不存在') # 返回不存在

 遍历字典
  无须转换成list 格式，保留了字典原有的特性

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
for i in d: #默认：直接对字典进行遍历，临时变量会接收到字典的key
    print(i)

	运行结果：C罗纳尔多
	         内马尔
	         拉莫斯
	         李毅
	         梅西
	         苏亚雷斯
	         莱万多夫斯基
	         诺伊尔

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
for i in d: #或者可以写成 for i  in d.keys()
    print(i,':',d[i])

	运行结果：C罗纳尔多 : 94
	         内马尔 : 92
	         拉莫斯 : 90
	         李毅 : 66
	         梅西 : 93
	         苏亚雷斯 : 92
	         莱万多夫斯基 : 91
	         诺伊尔 : 92	

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
for v in d.values():  # 单独对values进行遍历
    print(v)

	运行结果：94
	         92
	         90
	         66
	         93
	         92
	         91
	         92

d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
for i,k in d.items():
    print(i,k)

	运行结果：C罗纳尔多 94
	         内马尔 92
	         拉莫斯 90
	         李毅 66
	         梅西 93
	         苏亚雷斯 92
	         莱万多夫斯基 91
	         诺伊尔 92

# 我想给所有人都减去10分
d = {'C罗纳尔多':94,'内马尔':92,'拉莫斯':90,'李毅':66,'梅西':93,'苏亚雷斯':92,'莱万多夫斯基':91,'诺伊尔':92}
for i in d:
	d[i] -= 10
#我想给偶数加10分，奇数减10分
for i in d:
    if d[i] % 2 == 0:
        d[i] += 10
    else:
        d[i] -= 10	

 将其他数据处理成字典

   利用for循环

names = ['罗纳尔多', '梅西', '内马尔','苏亚雷斯', '诺伊尔', '莱万多夫斯基', '拉莫斯' ]
scores = [94, 93, 92, 92, 92, 91, 90]
test = {}
for i in range(len(names)): # 相当于列表的索引
    test(names[i]) = socres[i]

  enumerate 同时返回索引值和对应的值

names = ['罗纳尔多', '梅西', '内马尔','苏亚雷斯', '诺伊尔', '莱万多夫斯基', '拉莫斯' ]
scores = [94, 93, 92, 92, 92, 91, 90]
d = {}
for number,name in enumerate(names):
    d[name] = scores[number]

练习

  练习一：dict = {"k1":"v1","k2":"v2","k3":"v3"}

• 请在字典中增加一个键值对,“k4”:“v4”，输出添加后的字典
• 请删除字典中键值对"k1":“v1”,并输出删除后的结果
• 请获取字典中"k2"对应的值
• 请删除字典中键"k5"对应的键值对，如果字典中不存在键"k5",则不报错，返回None

dict = {"k1":"v1","k2":"v2","k3":"v3"}
dict['k4'] = 'k4'
dict.pop('k1')
dict['k2']
dict.pop('k5','不存在')

  练习二：dict = {"k1":"v1","k2":"v2","k3":"v3"}

• 请循环遍历出所有的key
• 请循环遍历出所有的value
• 请循环遍历出所有的key和value,中间用冒号分割
• 把所有value变成原来的值的两次重复,例如"v1"变成"v1v1"

dict = {"k1":"v1","k2":"v2","k3":"v3"}
for k in dict:
    print(k)
for v in dict:
    print(dict[v])
for k in dict:
    print(k,':',dict[k])
for k,v in dict.items():
    print(k,':',dict[k])
for k in dict:
    dict[k] = dict[k] * 2
dict

集合

  集合（set）是一个无序的不重复元素序列。

  set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

  其实集合就是一个没有value的dict

  注意：要创建一个set，需要提供一个list作为输入集合：

# 要创建一个set，需要提供一个list作为输入集合：
s = set([1, 2, 3])
print(s)
# 要注意的是set是无序的, 虽然这里1, 2, 3是顺序显示的
s1 = set([2, 1, 3])
print(s1)

	运行结果：{1, 2, 3}
             {1, 2, 3}

 set的一个常规应用时过滤重复值

# 字典key：只能用不可变数据类型，而且不能重复
s1 = ([1,2,,3,['a','b']])   # 程序会报错
s = set([1, 1, 2, 2, 3, 3]) # 去重
# 返回结果为 {1, 2, 3}

 增加集合

  可以通过add(key)方法添加元素到set中，但对于已经存在的值不会有效果

s = set([1, 2, 3])
s.add(4) 
s.add(4)

	运行结果：{1, 2, 3, 4}
             {1, 2, 3, 4}

 删除集合

  可以通过remove(key)方法从集合中删除元素

s = set([1, 2, 3])
s.remove(4)

	运行结果：{1, 2, 3}

 两个set可以做数学意义上的交集、并集等操作

  和数学上的集合相同，可以用于计算交集，差集，并集等等

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2  # 交集两个都有
s1 | s2  # 并集
s1 - s2 # 差集
s1.intersection(s2) # 交集
s1.union(s2) # 并集

练习

  有元组 T1 = ('A','B','E','F','A','B',"A",'B',"C") T2 = ("B","E",'K','D')

• 去除元组T中的重复值,将结果赋值成Se
• 求Se 和 T2 的交集,并集
• 在Se中添加元素"Z"
• 清空Se

T1 = ('A','B','E','F','A','B',"A",'B',"C")
T2 = ("B","E",'K','D')
se = set(T1)
se & set(T2)
se.add('Z')
se.clear()