python第一节

1.列表、元组操作

列表（list）：列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

创建列表：
	>>>sample_list = ['jim', 'tom', 'lilei']
	通过下标访问列表中的元素，下标从0开始计数　　　　
	>>>sample_list[0]
	'jim'
	>>>sample_list[2]
	'lilei'
	>>>sample_list[-1]
	'lilei'
	>>>sample_list[-2]
	'tom'
追加append：
	>>>sample_list
	['jim', 'tom', 'lilei']
	>>>sample_list.append('lily')
	>>>sample_list
	['jim', 'tom', 'lilei', 'lily']
插入insert：在指定的索引位置插入，之前在该索引位置及其后的位置的元素索引都加1。
	>>>sample_list
	['jim', 'tom', 'lilei', 'lily']
	>>>sample_list.insert(1, 'lucy')　　#在下标为1的位置插入'lucy'
	>>>sample_list
	['jim', 'lucy', 'tom', 'lilei', 'lily']
	>>>sample_list.insert(3,'jane')　　#在下标为3的位置插入'jane'
	>>>sample_list
	['jim', 'lucy', 'tom', 'jane', 'lilei', 'lily']
删除del,remove,pop：
	>>>sample_list
	['jim', 'lucy', 'tom', 'jane', 'lilei', 'lily']
	>>>del sample_list[1]　　#索引为1的元素'lucy'被删除
	>>>sample_list
	['jim', 'tom', 'jane', 'lilei', 'lily']
	>>>sample_list.remove('tom')　　#删除元素'tom'
	>>>sample_list
	['jim', 'jane', 'lilei', 'lily']
	>>>sample_list.pop　　#删除最后一个元素
	'lily'
	>>>sample_list
	['jim', 'jane', 'lilei']
扩展extend：
	>>>sample_list
	['jim', 'jane', 'lilei']
	>>>names = ['tom', 'lily', 'lucy', 'hanmeimei']
	>>>sample_list.extend(names)　　#将names列表添加到sample_list中
	>>>sample_list
	['jim', 'jane', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei']
切片：
	>>>sample_list
	['jim', 'jane', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei']
	>>>sample_list[1:3]　　#取下标1至下标3之间的元素，包括下标1，不包括下标3
	['jane', 'lilei']
	>>>sample_list[0:-1]　　#取下标0至下标-1之间的元素，包括下标0，不包括下标-1
	['jim', 'jane', 'lilei', 'tom', 'lily', 'lucy']
	>>>sample_list[:-1]　　#从头开始取，0可以忽略与上句一样的效果
	['jim', 'jane', 'lilei', 'tom', 'lily', 'lucy']
	>>>sample_list[0::2]　　#从下标0开始第隔一个元素取值
	['jim', 'lilei', 'lily', 'hanmeimei']
	>>>sample_list[::2]　　#与上句一样效果
	['jim', 'lilei', 'lily', 'hanmeimei']
修改：
	>>>sample_list
	['jim', 'jane', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei']
	>>>sample_list[1] = 'Angela'　　#下标1对应的元素被替换成'Angela'
	>>>sample_list
	['jim', 'Angela', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei']
获取下标：
	>>>sample_list
	['jim', 'Angela', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei']
	>>>sample_list.index('tom')　　#获取元素'tom'的下标
	3
统计count：
	>>>sample_list.append('lucy')
	>>>sample_list
	['jim', 'Angela', 'lilei', 'tom', 'lily', 'lucy', 'hanmeimei', 'lucy']
	>>>sample_list.count('lucy')　　#统计元素'lucy'在列表中的个数
	2

元组（tuple）：元组与列表类似，但元组创建后就无法修改，双被称作只读列表。

创建：
	>>>name_tuple = ('jim', 'tom', 'lilei', 'tom')
	('jim', 'tom', 'lilei', 'tom')
统计count：
	>>>name_tuple.count('tom')
	2
获取下标index：
	>>>name_tuple.index('lilei')
	2

2.字典

字典是一种键-值的数据类型，字典是无序的，key是唯一的。

例:
	name_dict = {'jim':'england','tom':'USA','lilei':'china'}
增加：
	>>>name_dict['lily'] = 'USA'
	{'jim': 'england', 'lily': 'USA', 'lilei': 'china', 'tom': 'USA'}
修改：
	>>>name_dict['lily'] = 'england'　　#修改与增加其实为同一功能，当key不存在时，给该key赋值为增加，当key不存在时，给该key赋值为修改
	>>>name_dict
	{'jim': 'england', 'lily': 'USA', 'lilei': 'china', 'tom': 'england'}
删除：
	>>>name_dict.pop('tom')　　#删除指定的元素'tom'
	'USA'
	>>>name_dict
	{'jim': 'england', 'lily': 'USA', 'lilei': 'china'}
	>>>del name_dict['lily']　　#删除指定元素'lily'
	>>>name_dict
	{'jim': 'england', 'lilei': 'china'}
	>>> name_dict['lily'] = 'USA'
	>>>name_dict
	{'jim': 'england', 'lily': 'USA', 'lilei': 'china'}
	>>>name_dict.popitem()　　#随机删除字典中的元素
	('jim', 'england')
	>>>name_dict
	{'lily': 'USA', 'lilei': 'china'}
查找：
	>>>name_dict
	{'lily': 'USA', 'lilei': 'china'}
	>>>name_dict.get('lily')　　#获取键'lily'对应的值
	'USA'
	>>>name_dict['lily']　　#效果和上面一句一样
	'USA'
	>>>name_dict['tom']		#如果一个key不存在，就会报错，get则不会，key不存在时只返回None
	Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
	KeyError: 'tom'
	>>>'lily' in name_dict　　#判断字符串'lily'是否在字典中
	True
	>>>name_dict.keys()　　#获取字典中所有的key
	dict_keys(['lily', 'lilei'])
	>>>name_dict.values()　　#获取字典中所有的value
	dict_values(['england', 'china'])
字典的嵌套：字典中可以嵌套字典、列表和元组，可以实现多级嵌套。
{'name_tuple': ('tt', 'tc'), 'lily': 'england', 'lilei': 'china', 'name_list': ['jim', 'tom'], 'record': {'server': '127.0.0.1', 'weight': '20', 'maxconn': '3000'}}

3.集合

集合是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.
	>>>x = set('world')
	>>>y = set(['o', 'r', 'l', 'd'])
	>>>x & y　　#交集
	{'r', 'l', 'o', 'd'}
	>>>x | y　　#并集
	{'d', 'r', 'o', 'w', 'l'}
	>>>x - y　　#差集(元素在x中，但不在y中)
	{'w'}
	>>>x ^ y　　#对称差集(元素在x或y中，但不同时出现在二者中)
	{'w'}
基本操作：
	>>>x.add('z')　　#添加一个元素
	>>>x
	{'d', 'r', 'o', 'z', 'w', 'l'}
	>>>y.update(['a', 'b', 'c'])　　#添加多个元素
	>>>y
	{'a', 'd', 'r', 'b', 'o', 'c', 'l'}
	>>>y.remove('a')　　#删除一个元素a，如果不存在则引发KeyError
	>>>y
	{'d', 'r', 'b', 'o', 'c', 'l'}
	>>>y.discard('z')　　#如果y中存在元素z，则删除
	>>>y.pop()　　#在y中随机删除并返回一个元素，若y为空则引发KeyError
	>>>y.clear()　　#删除y中所有元素
	>>>len(x)　　#集合x的长度
	6
	>>>x in y　　#测试x是否是y的成员
	False
	>>>x not in y　　#测试x是否不是y的成员
	True





	x.issubset(y)
	x <= y　
	测试x是否每个元素都在y中　　　　

	x.issuperset(y)
	x >= y
	测试y是否每个元素都在x中　　　　

	x.union(y)
	x | y
	返回一个新的set包含x和y中每一个元素　　　

	x.intersection(y)
	x & y
	返回一个新的set包含x和y中的公共元素　　　

	x.difference(y)
	s - t
	返回一个新set包含x中有但t中无的元素

	x.symmetric_difference(y)
	x ^ y
	返回一个新set包含在x或y中，但不同时出现在二者中的元素

5.文件操作

1.打开文件，得到文件句柄并赋值给一个变量；
2.通过句柄对文件进行操作；
3.关闭文件。
关于open的模式：
	r　　只读模式
	w　　只写模式，不可读，若不存在则创建，存在则覆盖
	a　　追加模式，可读，不存在则创建，存在则追加
	r+　　可读写
	w+　　可读写
	a+　　可读写
	rb　　 二进制读模式
	wb　　 二进制写模式
	ab　　二进制追加模式
	rU　　"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n

	with语句：
	with open('test.txt', 'r') of read_file:
		......
	当with代码块执行完毕，可自动关闭并释放文件。

6.函数

1.函数基本语法及特性

函数是组织好的，可重复使用的，用来实现单一，或相关功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

定义函数的规则：

函数代码块以def关键词开头，后接函数标识符名称和圆括号()；

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数；

函数的第一行语句可以选择性地使用文档字符串用于存放函数说明；

函数内容以冒号起始，并且缩进；

return [表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

语法：

def functionname( parameters):
	"函数_文档字符串"
	function_suite
	return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例：

def helloworld():	#函数名
	print("Hello world!!!")

helloworld()	#调用函数

可以带参数

def calc(a,b):
    res = x**y
    return res	#返回函数执行结果

c = cacl(1, 2)	#结果赋值给c变量
print(c)	#打印c的值

2.函数参数与局部变量

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

默认参数：

def stu(id,name,age,course="mysql"):
   	print("------注册学生信息------")
   	print("ID:", id)
   	print("姓名:", name)
   	print("年龄:", age)
   	print("课程:", course)

stu(1, "jim", 18, "mysql")
stu(2, "tom", 18, "oracle")
stu(3, "lilei", 20)

关键参数:
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键字参数，只需指定参数名即可，但记住一个要求是，关键参数必须放在位置参数之后。

非固定参数:
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def stu(id, name, *args):	#*args会把多传入的参数变成一个元组形式
   	print(id, name, args)

stu(1, "tom")
#输出
#1 tom ()	#后面这个()就是args，只是因为没传值，所以为空。

stu(2, "jim", 18, "python")
#输出
#2 jim (18, 'python')

**kwargs

def stu(id, name, *args, **kwargs):	# **kwargs会把多传入的参数变成一个dict形式
   	print(id, name, args, kwargs)

stu(1, "tom")
#输出
#1 tom ()	#后面这个()就是args，只是因为没传值，所以为空

stu(2, "jim", 18, "python"，sex="Male", province="guangdong")
#输出
# 2 jim (18, 'python') {'province': 'guangdong', 'sex': 'Male'}

全局变量和局部变量:

定义在函数内部的变量拥有一个局部的作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 0	#这是一个全局变量
def sum(arg1, arg2):
   	#返回两个数的和
   	total = arg1 + arg2	#total在这是一个局部变量
   	print("函数内是局部变量：", total)
   	return total

#调用sum函数
sum(1, 2)
print("函数外是全局变量：", total)

以上实例输出结果：

函数内部是局部变量：3
函数外部是全局变量：0

返回值：
要想获取函数的执行结果，可以用return语句把结果返回。

注意：
	1.函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so也可以理解为return语句代表着函数的结束
	2.如果未在函数中指定return，那这个函数的返回值为None

匿名函数：
匿名函数就是不需要显式的指定函数

#这段代码
def calc(c):
   	return n*n

print(calc(10))

#换成匿名函数
calc = lambda n:n*n
print(calc(10))

高阶函数：
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称作高阶函数。

def add(x, y, f):
   	return f(x) + f(y)

res = add(3, -6, abs)
print(res)

内置参数：

posted @ 2017-03-05 14:44 wowermvp 阅读(135) 评论(0) 收藏举报

刷新页面返回顶部

wowermvp

python第一节

python第一节

1.列表、元组操作

2.字典

3.集合

5.文件操作

6.函数

1.函数基本语法及特性

2.函数参数与局部变量

公告