1、元组：

元组只包含一个元素时，需在元素后加逗号，否则括号会被当做运算符；
元组访问可使用下标的方式，例如：

tup = (1, 2, 3)
print tup[1:]


元组脚本常用操作：

tup = (1, 2, 3)									#初始化元组
len(tup)											#获取元组长度；
3 in tup											#判断3是否在元组中；
for x in tup: print(x, end='" ")			#迭代访问元组， python默认打印换行，若不想换行末尾加上end


元组可使用"+“进行元组组合拼接， 可使用”*"表示复制拼接，例如：

(1, 2) + (5, 6)  ->  (1, 2, 5, 6)
('a', ) * 2 -> ('a', 'a')


删除元组使用del语句来实现，切记此时删除的为整个元组，执行后元组变量不再存在；
元组内置函数：

len(tup)		#计算元组元素的个数
max(tup)		#返回元组中元素的最大值
min(tup)		#返回元组中元素的最小值
tuple(l)		#将列表转换为元组

2、列表：

访问列表和元组一样，通过下标的方式；
列表元素的变更操作：

list = [1, 2, 3, 4]
list[2] = 5					#将第三个元素的值修改为5
del[1]						#删除第二个元素


列表脚本常用操作同元组；
python列表函数，同样包含函数  len  max  min, 可用list(tup)函数将元组转换为列表；
python包含的方法：

list.append(obj)						#在列表末尾添加新元素
list.count(obj)							#计算指定元素在列表中出现的次数
list.extend(list1)						#在列表末尾追加list1中的元素
list.index(obj)							#找出列表中指定元素第一次出现的索引值
list.insert(index, obj)					#在列表指定位置插入新元素
list.pop([index=-1])					#移除列表中指定索引位置的元素（默认为最后一个），并返回改元素的值
list.remove(obj)						#移除列表中指定值的第一个匹配项
list.reverse()							#翻转列表
list.sort(key=None, reverse=False)		#对原列表进行排序
list.clear()							#清空列表
list.copy()								#复制列表

3、字典

访问修改字典的值，可通过键来索引，例如：

dict = {'name': 'jack', 'age': 18 }
dict['name']		#回去name对应的值
dict['age'] = 20	#修改age对应的值
del dict['name']	#删除键'name'
dict.clear			#清空字典
del dict			#删除字典


字典中的值可以是任何python对象，但是键必须是不可修改的，例如数字，字符串或者元组都可以，同一个键在一个字典中不允许重复出现。
字典的内置函数：

len(dict)			#计算字典元素的个数
str(dict)			#以可打印字符串的形式输出字典
type(dict)			#返回变量类型


包含的python方法：

dict.clear()									#清空字典
dict.copy()										#浅拷贝字典 
dict.get(key, default=None)						#返回指定键的值，如不存在则默认返回None
key in dict										#判断键是否在字典中，在返回true 否则返回false
dict.items()									#以列表返回可遍历的(键, 值) 元组数组
dict.keys()										#返回字典键的迭代器，可用list()转换成列表
dict.values()									#返回字典值的迭代器，可用list()转换成列表
dict.setdefault(key, default=None)				#类似于get，但若key不存在则会添加键并设置默认值为None
dict.update(dict2)								#将字典dict2的键值对更新到dict中
pop(key[,default])								#删除给定键的值并返回，若键不存在则返回default值

直接赋值、浅拷贝和深拷贝解析

4、集合

集合是一个无序不重复的序列，集合会自动去除重复的元素
集合的基本操作：

set.add(x)			#添加元素
set.update(x)		#添加元素的另一种方法，若值为多个以"，"隔开，参数可以是列表，元组，字典等
set.remove(x)		#删除元素，若不存在将报错
set.discard(x)		#删除元素，且元素不存在时不报错
set.pop()			#随机删除集合中的一个元素
len(set)			#计算集合中元素的个数
set.clear()			#清空集合
x in set			#判断x是都在集合中


集合的其他内置函数

union()				#返回多个集合的并集
difference()		#返回多个集合的差集
intersection()		#返回多个几个的交集

#列表 字典 集合 类 ----局部变量可以改全局变量，除了整数和字符串
names=["alex","jack","luck"]
def func(names):
    names[0]='金角大王'
    print("inside name:" ,names)

func(names)
print (names)

#字符串
name='jack'
name1=name 
name='jack_chen'
print(name,name1)#name的值为jack_chen ,name1的值为jack


 
转载于:https://www.cnblogs.com/xuehuahongmei/p/5958457.html

字典:存储数据的一种容器,字典中存储的数据都是无序的,可以取数据的时候不能根据索引取,可以根据key(键)取出对应的value(值) 键必须是唯一的,不可变的




dict_1 = {

#key:value

'name':'zhangsan',

'age':22,

'phone':110,

'height':180,

'weight':80,

'love':'write code'

}

print dict_1




#向字典中添加数据

#字典[key] = value

#如果key在字典中，修改key对应的数据

#如果key不在字典中，添加数据

dict_1['name'] = 'lisi'

print dict_1

dict_1['sex'] = 'nan'

print dict_1




#字典中存储的数据都是无序的，可以取数据的时候不能根据索引取，可以根据key(键)取出对应的value(值)

#注意：取数据的时候如果使用下面这种方式，必须保证key在字典中，如果不在，会造成下面这种错误

#keyError:'hsjhd'

# s = dict_1['hsjhd']

s = dict_1['love']

print s



#get()函数根据key取数据，如果key不存在，返回一个None值

s_1 = dict_1.get('hsjhd')

print s_1



#pop()从字典中取出对应key的数据，并且从字典中移除该数据

s = dict_1.pop('age')

print s,dict_1



#popitem()随机从字典中移除某个key,value

#使用场景：一个一个的把字典中的数据移除，可以利用while循环+popitem函数，实现一个一个移除

s = dict_1.popitem()

print s

print dict_1



#clear()函数移除字典中的所有的key,value

dict_1.clear()

print dict_1



#keys()函数，获取字典中所有的键

#values()函数，获取字典中所有的值

#获取到的键和值，都是以列表的形式返回

keys = dict_1.keys()

print keys

values = dict_1.values()

print values



#遍历字典的第一种方式

for k in keys:

#遍历所有的key键，根据key键取出字典中的值

v = dict_1[k]

print k,v



#for 循环遍历循环字典的第二种方式

items = dict_1.items()

print items

for key,value in items:

print key,value



dict_1 = {}

s = ['age','name','phone']

#fromkeys()会根据s列表中的数据作为key生成一个新的字典，所有的key对应的值默认为None

#1.所有key的列表

#2.所有key对应的默认值

dict_2 = dict_1.fromkeys(s,'default')

print dict_2



#has_key()判断字典中是否有某个key

#有返回True 没有返回False

rs = dict_2.has_key('s')

print rs



#向字典中添加数据 setdefaulte()

#添加一个新的key，默认key对应的值为None

#如果填两个参数，添加一个新的key，对应的值为第二个参数

dict_2.setdefault('sex','nan')

print dict_2



#update()函数、如果dict_3中的key在dict_2中也有，会把dict_2中key对应的数据更新，如果没有，添加到dict_2中

dict_3 = {'a':1,'b':2,'name':'zhangsan','age':22}

dict_2.update(dict_3)

print dict_2






元组:可以存储数据,一旦元组找到那个存储的数据确定后,就不可以在进行增删改了




集合:存储数据的一种方式,集合中的数据是无序的,集合中没有重复的数据,数据一旦确定后就不能更改







列表:是一个可变的容器,具有增删改查的功能,可以存储任意类型的数据,存储数据有顺序,可以根据索引取数据

#声明列表,初始化一个列表

list_1 = ['hello',1,2,3,'world','True']

#向列表中添加数据

#1.append()追加数据,会把数据放在列表末尾

list_1.append('nnnn')

#2.insert() 在指定的位置之前插入数据 

#参数1：指定插入的索引位置,超出最大索引，会把数据添加到列表最后，如果是负值从后向前 传参数

#参数2.要插入的数据

list_1.insert(2,'next')

print list_1



#修改列表中的数据

#根据索引修改列表中的数据

list_1[1] = 'aaa'

print list_1 

#IndexError: list assignment index out of range表明索引超出了最大索引



# #删除列表中的数据

# #1.根据索引删除列表中的数据

# del list_1[2]



# #2.remove()根据内容删除

list_1.remove('aaa')

print list_1



# #3.pop()函数,删除最后一条数据

# list_1.pop()

# print list_1



# #取出最后一条数据并从列表中删除

s = list_1.pop()

print s

如何在列表字典集合中根据条件筛选数据
一：列表
先随机生成一个列表，过滤掉负数

1，普通for循环迭代判断
2，filter()函数判断,filter(函数，list|tuple|string)


1 filter(lambda x:x>0,data)


3,列表推倒式

4，效率对比：还是列表推导式稍高

二：字典
1，跟列表类似，推导式
先生成随机的字典（key从1-20）

过滤掉value是负数的值

 
 三：集合
随机生成10个元素的集合
 
 
过滤掉小于0的元素，跟字典类似
 
 
转载于:https://www.cnblogs.com/ruoniao/p/6814088.html