python列表，字典，元组

python变量赋值
	常量 不变化的量，比如数字，字符串都是
	变量 存储常量，通常由变量名指出
	赋值 就是将一个常量指向一个变量
	name = 'while'
	python是一门弱变量的语言，所用变量即用即生成，变量的类型随着值的类型的修改而修改
命名可用的内容
	字母
	数字
	下划线
		1、数字不可以开头，也不可以纯数字
		2、__开头代表私有
		3、__name__代表魔术方法
		4、关键字不可以用于命名
		>>>import keyword
		>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 
'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
		5、命名要有意义，禁止无意义的命名，比如，a,a1,bb
	常见的命名
		名词
			name = 1
		动宾结构
			get page = 1
			getPage = 1
			GetPage = 1
		变量赋值的三种方式
			传统赋值
				name = 'while'
			链式赋值
				name = user = 'while'
			序列解包赋值
				name,age = 'while',10

			>>> name = 'while'
			>>> name
			'while'
			>>> name = user = 'while'
			>>> name,user
			('while', 'while')
			>>> name,age = 'shuai',18
			>>> name,age
			('shuai', 18)
			>>> hello		变量不存在
			Traceback (most recent call last):
			  File "<pyshell#14>", line 1, in <module>
			    hello
			NameError: name 'hello' is not defined
			>>> name,age = 'shuai',18,00		变量和常量不对应
			Traceback (most recent call last):
			  File "<pyshell#15>", line 1, in <module>
			    name,age = 'shuai',18,00
			ValueError: too many values to unpack (expected 2)

python列表
	列表是一个元素以逗号分割，以中括号包围的，有序的，可修改的序列
		python2
			1、list
			2、[]
			3、range
			4、xrange
		python3
			1、list
					>>> list('abced')
					['a', 'b', 'c', 'e', 'd']
					>>> str(['a','b','c','d'])
					"['a', 'b', 'c', 'd']"
					>>> ''.join(['a','b','c'])
					'abc'
			2、[]
					>>> ['a',1,[1,'a']]
					['a', 1, [1, 'a']]
			3、range
					>>> range(100)
					range(0, 100)
					>>> list(range(100))
					[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
					16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
					30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 
					44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 
					58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 
					72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 
					86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
					>>> print(range(100))
					range(0, 100)	
列表的索引
	列表的索引和字符串的索引类似，但不完全相同，因为列表可以修改，所以我们可以通过列表
	的索引来修改列表
	一样的部分
		>>> mylist = [1,2,3,45,6]
		>>> mylist
		[1, 2, 3, 45, 6]
		>>> mylist1 = list('123456')
		>>> mylist1
		['1', '2', '3', '4', '5', '6']
		>>> mylist[1]
		2
		>>> mylist[-1]
		6
		>>> mylist[:]
		[1, 2, 3, 45, 6]
		>>> mylist1[::2]
		['1', '3', '5']
		>>> mylist1[5:1:-1]
		['6', '5', '4', '3']
		>>> mylist1[1] = 's'
		>>> mylist1
		['1', 's', '3', '4', '5', '6']
	超出索引范围
		>>> mylist1[100]
		Traceback (most recent call last):
		  File "<pyshell#38>", line 1, in <module>
		    mylist1[100]
		IndexError: list index out of range

	列表的方法
		
		列表的添加	
			append	追加，在列表的尾部加入指定的元素
			extend	将指定序列的元素依次追加到列表的尾部
			insert	将指定的元素插入到对应的索引位上，注意负索引
		列表的删除	
			pop	弹出，返回并删除指定索引位上的数据，默认-1
			remove	从左往右删除一个指定的元素
			del	删除是python内置功能，不是列表独有的
		列表的查找
		注 列表没有find方法	
			count	计数，返回要计数的元素在列表当中的个数
			index	
			查找，从左往右返回查找到的第一个指定元素的索引，如果没有找到，报错
		列表的排序	
			reverse	索引顺序倒序
			sort	按照ascii码表顺序进行排序

		append 		列表末尾添加
			>>> mylist = list('1a23456')
			>>> mylist
			['1', 'a', '2', '3', '4', '5', '6']
			>>> mylist.append('a')
			>>> mylist
			['1', 'a', '2', '3', '4', '5', '6', 'a']
			>>> mylist.append([123])
			>>> mylist
			['1', 'a', '2', '3', '4', '5', '6', 'a', [123]]
			>>> mylist.append('[123]')
			>>> mylist
			['1', 'a', '2', '3', '4', '5', '6', 'a', [123], '[123]']

		extend		将序列直接添加到末尾
			>>> mylist = list('123456')
			>>> mylist
			['1', '2', '3', '4', '5', '6']
			>>> mylist.extend('123')
			>>> mylist
			['1', '2', '3', '4', '5', '6', '1', '2', '3']

			insert 		将元素直接添加到指定位置
			>>> mylist.insert('a',0)	注意顺序
			Traceback (most recent call last):
			  File "<pyshell#51>", line 1, in <module>
			    mylist.insert('a',0)
			TypeError: 'str' object cannot be interpreted as an integer
			>>> mylist.insert(0,'a')

		pop  默认弹出最后一个位置，可以指定弹出的元素
			>>> mylist
			['a', '1', '2', '3', '4', '5', '6', '1', '2', '3']
			>>> mylist.pop()
			'3'
			>>> mylist
			['a', '1', '2', '3', '4', '5', '6', '1', '2']
			>>> mylist.pop()
			'2'
			>>> mylist
			['a', '1', '2', '3', '4', '5', '6', '1']
			>>> list(mylist)
			['a', '1', '2', '3', '4', '5', '6', '1']
			>>> mylist.pop(0)	弹出指定位置的元素
			'a'

		remove	从左往右删除指定的元素，一次删除一个
			>>> mylist
			['1', '2', '3', '4', '5', '6', '1']
			>>> mylist.remove(1)
			Traceback (most recent call last):
			  File "<pyshell#63>", line 1, in <module>
			    mylist.remove(1)
			ValueError: list.remove(x): x not in list
			>>> mylist.remove('1')
			>>> mylist
			['2', '3', '4', '5', '6', '1']

		del 	删除指定位置的元素
			>>> del mylist[1]
			>>> mylist
			['2', '4', '5', '6', '1']
			>>> del mylist[0]
			>>> mylist
			['4', '5', '6', '1']
			>>> del mylist('1')
			SyntaxError: can't delete function call
			>>> del mylist
			>>> mylist
			Traceback (most recent call last):
			  File "<pyshell#72>", line 1, in <module>
			    mylist
			NameError: name 'mylist' is not defined
		
		count	寻找指定元素的个数  #注意list方法和[]这个的区别
		 一个是字符串一个是数字 使用函数的方法也不一样
			>>> mylist = list('12345')
			>>> mylist
			['1', '2', '3', '4', '5']
			>>> mylist.count(0)
			0
			>>> mylist.count(1)
			0
			>>> mylist.count(2)
			0
			>>> mylist = list('1234566')
			>>> mylist
			['1', '2', '3', '4', '5', '6', '6']
			>>> mylist.count(6)
			0
			>>> mylist.count('6')
			2
			>>> mylist = [1,2,3,4]
			>>> mylist.count(1)
			1
			>>> mylist
			[1, 2, 3, 4]
		
		index 	从左往右寻找指定元素的索引，第一个元素
			>>> mylist
			[1, 2, 3, 4]
			>>> mylist.index(1)
			0
			>>> mylist.index(2)
			1
			>>> mylist.index(3)
			2
			>>> mylist = list('1234')
			>>> mylist.index('1')
			0
			>>> mylist.index(1)
			Traceback (most recent call last):
			  File "<pyshell#93>", line 1, in <module>
			    mylist.index(1)
			ValueError: 1 is not in list
		
		reverse 	按照索引顺序进行倒序
			>>> mylist
			['1', '2', '3', '4']
			>>> mylist.reverse()
			>>> mylist
			['4', '3', '2', '1']
			>>> mylist = list('dadgasgreaghfdah')
			>>> mylist
			['d', 'a', 'd', 'g', 'a', 's', 'g', 'r', 'e', 'a', 'g', 'h', 'f', 
			'd', 'a', 'h']
			>>> mylist.reverse()
			>>> mylist
			['h', 'a', 'd', 'f', 'h', 'g', 'a', 'e', 'r', 'g', 's', 'a', 'g', 
			'd', 'a', 'd']

		sort	直接按照ascii码排序，不能数字和字符一起排序
			>>> mylist
			['h', 'a', 'd', 'f', 'h', 'g', 'a', 'e', 'r', 'g', 's', 'a', 'g', 'd', 'a', 'd']
			>>> mylist.sort()		 
			>>> mylist
			['a', 'a', 'a', 'a', 'd', 'd', 'd', 'e', 'f', 'g', 'g', 'g', 'h', 'h', 'r', 's']
			>>> mylist = [1,2,3,4]
			>>> mylist.sort()
			>>> mylist
			[1, 2, 3, 4]
			>>> mylist = [1,'a',2,3]
			>>> mylist
			[1, 'a', 2, 3]
			>>> mylist.sort()
			Traceback (most recent call last):
			  File "<pyshell#109>", line 1, in <module>
			    mylist.sort()
			TypeError: '<' not supported between instances of 'str' and 'int'
			>>> mylist = [1,2,3,'1']
			>>> mylist.sort()
			Traceback (most recent call last):
			  File "<pyshell#111>", line 1, in <module>
			    mylist.sort()
			TypeError: '<' not supported between instances of 'str' and 'int'
python元组
	元组是元素以逗号分割，以小括号包围的有序的，不可修改的序列
	tuple()
	构建元组的方法
		
		>>> mytuple = tuple('12345')
		>>> mytuple
		('1', '2', '3', '4', '5')
		
		>>> ('a',1,3)
		('a', 1, 3)
	元组的索引和字符串是一样的
		>>> mytuple
		('1', '2', '3', '4', '5')
		>>> mytuple.count('1')
		1
		>>> mytuple.count(2)
		0
		>>> mytuple.count('2')
		1
		>>> mytuple.count('1')
		1
		>>> mytuple.count('3')
		1
		>>> mytuple[::-1]
		('5', '4', '3', '2', '1')
		>>> mytuple[-1]
		'5'
		>>> mytuple
		('1', '2', '3', '4', '5')
		>>> mytuple[1]
		'2'
		>>> mytuple[0:3]
		('1', '2', '3')
		>>> mytuple[5:0:-1]
		('5', '4', '3', '2')
		>>> mytuple[5::-1]
		('5', '4', '3', '2', '1')
	元组的特性
		元组可以不加括号
			>>> 1,2
			(1, 2)
		单元素元组需要加逗号
			>>> type([1])
			<class 'list'>
			>>> type((1))
			<class 'int'>
			>>> type((21,))
			<class 'tuple'>
		元组不可修改，所以我们再配置文件中多看到元组
			Django 配置的一部分
			DATABASE = (
			Os.path.join(BASEDIR," TEMPLATE"),
			)
	元组的方法
		元组的查找
			index 	从左往右指定元素的索引，遇见的第一个元素
			count	寻找元组中的指定的元素的个数
				>>> mytuple
				('1', '2', '3', '4', '5')
				>>> mytuple.index('1')
				0
				>>> mytuple.index('5')
				4
				>>> mytuple.count('1')
				1
				>>> mytuple.count('5')
				1
元组和字符串的区别
	1、元组和字符串都是有序的，不可修改的序列
	2、元组的元素可以是任何类型，字符串的元素只能是字符
	3、元组的元素长度可以任意，字符串的元素长度只能为 1
验证元组和字符串的长度
	>>> a
	'abc'
	>>> mytuple
	'shuai'
	>>> len(a[0])
	1
	>>> len(mytuple[0])
	1
	>>> mytuple = ('shuai',1)
	>>> mytuple
	('shuai', 1)
	>>> len(mytuple[0])
	5
元组的创建方法
	>>> a
	'shuai'
	>>> mytuple = ('shuai',a)
	>>> mytuple
	('shuai', 'shuai')
	
	>>> mytuple = ('shuai',1)
	>>> mytuple
	('shuai', 1)
	>>> len(mytuple[0])
	5
	
	>>> mytuple = ('shuai',a)	a = 'shuai'
	>>> mytuple
	('shuai', 'shuai')
	>>> len(mytuple[0])
	5
	
	>>> mytuple = ('shuai',b)	引入字符串必须放在引号里
	Traceback (most recent call last):
	  File "<pyshell#196>", line 1, in <module>
	    mytuple = ('shuai',b)
	NameError: name 'b' is not defined
	>>> mytuple = ('shuai','b')
	>>> mytuple
	('shuai', 'b')
	
	>>> mytuple = ('shuai',1) 数字可以放在外面
	>>> mytuple
	('shuai', 1)
	
	>>> mytuple = ('shuai',)
	>>> mytuple
	('shuai',)
	>>> len(mytuple[0])
	5
	
	>>> mytuple = ('shuai,shuai')  与这个区分，这是字符串的创建方法

python字典
	字典一个元素呈键值对的形式，以逗号分割，以大括号包围的无序的，可以修改的序列。
	字典是python基础数据类型当中唯一一个映射关系的数据类型，通常对应JSON{}
		字典创建方法
			>>> mydict = {'a':1,"b":2}
			>>> mydict
			{'a': 1, 'b': 2}
		fromkeys	这种方法只能给所有的键都赋一样的值
			>>> mydict = {}.fromkeys('abcd')
			>>> mydict
			{'a': None, 'b': None, 'c': None, 'd': None}
			>>> mydict = {}.fromkeys('abcd','shuai')
			>>> mydict
			{'a': 'shuai', 'b': 'shuai', 'c': 'shuai', 'd': 'shuai'}
	
	dict
		zip 
		函数：将几个序列对应索引位上的元素分到一个元组中，总的形成一个列表，子元组的
		个数取决于提供的序列的最小长度
	python2 与python3的区别
		python2 直接返回对象
		python3 返回对象的内存地址，需要用列表进行转换
		补充：python3中减少了内存的占用，优化了性能但是速度更慢了

			>>> myzip = zip('abcd','1234')
			>>> myzip
			<zip object at 0x00000223D8276BC8>		python3中的内存地址
			>>> list(myzip)							
										元素啄一对应，长度取决于最小的序列的长度
			[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
			>>> myzip = zip('abcd','123456','shuai','1234')
			>>> myzip
			<zip object at 0x00000223D828A388>
			>>> list(myzip)
			[('a', '1', 's', '1'), ('b', '2', 'h', '2'), ('c', '3', 'u', 
			'3'), ('d', '4', 'a', '4')]
			
			>>> dict([('a',1),('b',2)])
			{'a': 1, 'b': 2}
			>>> dict(zip('abcdefg','1234567'))
			{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'e': '5', 'f': '6', 'g': '7'}
			>>> mydict = zip('abcd','1234')
			>>> mydict
			<zip object at 0x00000223D828AE08>
			>>> list(mydict)
			[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
			>>> mydict = dict(mydict)
			>>> mydict
			{}
			
			>>> mydict = zip('abcd','1234')
			>>> mydict = dict(mydict)
			>>> mydict
			{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
			>>> mydict = zip('abcd','1234')
			>>> mydict
			<zip object at 0x0000018304BCF2C8>
	
			>>> list(mydict)
			[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
			>>> dict(mydict)
			{}
			>>> mydict = zip('abcd','1234')
			>>> dict(mydict)
			{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
		mydict = zip('')	创建的是列表
		dict(zip())		列表转为字典
		dict([()])		元组-->列表-->字典

		字典的特点：
			因为字典是无序的，所以字典没有索引值
			因为字典没有索引值，所以字典以键取值，（字典的键相当于列表的索引）
				>>> myzip = dict(zip('abcd','1234'))
				>>> myzip
				{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
				>>> myzip['a']
				'1'
		因为字典以键取值，所以字典的键唯一且不可修改。
		因为字典的键不可修改，所以列表和字典不可以给字典做键。
				>>> myzip = {'a':1,1:'a',(1,2):'c'}
				>>> myzip
				{'a': 1, 1: 'a', (1, 2): 'c'}
				>>> myzip = {'a':1,1:'a',(1,2):'c',{'a':1}:1}
				Traceback (most recent call last):
				  File "<pyshell#48>", line 1, in <module>
				    myzip = {'a':1,1:'a',(1,2):'c',{'a':1}:1}
				TypeError: unhashable type: 'dict'
			字典和列表不可以作为字典的键
	字典的方法：
		字典的取值：
			keys		获取字典所有的键
			values		获取字典所有的值
			get 		以键取值，如果指定键不存在，默认返回None可以指定返回内容
			update		更新指定键的内容，如果键不存在就直接创建
			setdefault	设置默认，如果键存在，返回值，如果键不存在，创造键，值默认
						为None，值也可以自定义
			items		返回字典键值呈元组形式的格式
		字典的删除
			pop			弹出，返回并删除指定键对应的值
			popitem		随机弹出一个键值元组，这里随机的原因是因为字典无序
			clear		清空字典
				字典的取值
					>>> mydict = dict(zip('abc','123'))
					>>> mydict
					{'a': '1', 'b': '2', 'c': '3'}
				keys
					>>> mydict.keys()
					dict_keys(['a', 'b', 'c'])
				values
					>>> mydict.values()
					dict_values(['1', '2', '3'])
					>>> list(mydict.keys())
					['a', 'b', 'c']
					>>> list(mydict.values())
					['1', '2', '3']
					>>> mydict.get('a')
					'1'
					>>> mydict['a']
					'1'
					>>> mydict.get('x')
					>>> mydict['x']
					Traceback (most recent call last):
					  File "<pyshell#74>", line 1, in <module>
					    mydict['x']
					KeyError: 'x'

				>>> mydict.update(dict(zip('a',1)))
				Traceback (most recent call last):
				  File "<pyshell#75>", line 1, in <module>
				    mydict.update(dict(zip('a',1)))
				TypeError: zip argument #2 must support iteration
				>>> mydict.update({'a',1})
				Traceback (most recent call last):
				  File "<pyshell#76>", line 1, in <module>
				    mydict.update({'a',1})
				TypeError: cannot convert dictionary update sequence element #0 to a sequence
					>>> mydict
					{'a': '1', 'b': '2', 'c': '3'}
					>>> mydict.update({'a':1})
					>>> mydict
					{'a': 1, 'b': '2', 'c': '3'}
					>>> mydict.update({'a':2})
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3'}
					>>> mydict+{'y':1}
					Traceback (most recent call last):
					  File "<pyshell#83>", line 1, in <module>
					    mydict+{'y':1}
					TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
					>>> mydict.update({'x':55})
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55}

					>>> mydict.setdefault('x')
					55
					>>> mydict.setdefault('y')
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None}
					>>> mydict.setdefault('y',88)
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None}
					>>> mydict.setdefault('h',99)
					99
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None, 'h': 99}
					>>> mydict.items()
					dict_items([('a', 2), ('b', '2'), ('c', '3'), ('x', 55), 
					('y', None), ('h', 99)])
					>>> list(mydict.items())
					[('a', 2), ('b', '2'), ('c', '3'), ('x', 55), ('y', 
					None), ('h', 99)]
					>>> 
		字典的删除
			pop 	只能弹出指定的内容键，不能弹出数值
					>>> mydict.pop()
					Traceback (most recent call last):
					  File "<pyshell#96>", line 1, in <module>
					    mydict.pop()
					TypeError: pop expected at least 1 arguments, got 0
					>>> mydict.pop('y')
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55, 'h': 99}
					>>> mydict.pop('h')
					99
					>>> mydict
					{'a': 2, 'b': '2', 'c': '3', 'x': 55}
					>>> mydict.pop(55)
					Traceback (most recent call last):
					  File "<pyshell#101>", line 1, in <module>
					    mydict.pop(55)
					KeyError: 55

			popitem clear   随机弹出内容，清空内容
						>>> mydict
						{'a': 2, 'b': '2', 'c': '3', 'x': 55}
						>>> mydict.popitem()
						('x', 55)
						>>> mydict.popitem()
						('c', '3')
						>>> mydict.popitem()
						('b', '2')
						>>> mydict
						{'a': 2}
						>>> list(mydict.items())
						[('a', 2)]
						>>> mydict = dict(zip('abcd','1234'))
						>>> mydict
						{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
						>>> list(mydict.items())
						[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
						>>> mydict.popitem()
						('d', '4')
						>>> mydict.popitem()
						('c', '3')
						>>> mydict.popitem()
						('b', '2')
						>>> mydict
						{'a': '1'}
						>>> mydict.clear()
						>>> mydict
						{}
			python2中
				判断has_key
			python3
				用in 	替换
				in判定有没有指定的键
					>>> mydict = dict(zip('abcd','1234'))
					>>> mydict
					{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
					>>> 'a' in mydict		判断a 是否在字典里
					True
					>>> 2 in mydict
					False
					>>> '2' in mydict
					False

字典的拷贝属于浅层拷贝，拷贝和拷贝对象的嵌套层同属一个内存，一个修改另一个也会修改
	普通键对应的值发生变化，复制的字典值不变，列表对应的键值变了，复制的列表的对应的键值也变化
		>>> mydict
		{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
		>>> mydict.update({'z':[11]})
		>>> mydict
		{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
		>>> mydict_1 = mydict.copy()
		>>> mydict_1
		{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
		>>> mydict['a'] = 11
		>>> mydict
		{'a': 11, 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
		>>> mydict_1
		{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
		>>> mydict['z'][0] = 5
		>>> mydict
		{'a': 11, 'b': '2', 'c': '3', 'd': '4', 'z': [5]}
		>>> mydict_1
		{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [5]}

数据类型的总结
	
			str		list	tuple	dict
是否有序		是		是		是		否
是否可修改	不		可		不		可
方法多少		很多		一般		很少		较多   映射关系