字典，集合，函数，global全局变量声明

1.if实现switch

#!/usr/bin/env python
#coding=utf-8
while 1:
num1 = input("num1:")
oper = raw_input("操作符：")
num2 = input("num2:")

if oper == "+":
print num1 + num2
elif oper == "-":
print num1 - num2
elif oper == "*":
print num1 * num2
elif oper == "/":
if num2 == 0:
print "Error:分母为0"
else:
print num1 / num2
else:
print "操作符错误"

2.字典实现switch语句

#!/usr/bin/env python
#coding=utf-8
from __future__ import division

num1 = input("num1:")
oper = raw_input("操作符：")
num2 = input("num2:")

def add(num1,num2):
return num1 + num2

def sub(num1,num2):
return num1 - num2

def muilt(num1,num2):
return num1 * num2

def div(num1,num2):
if num2 == 0:
print "分母为0，参数错误"
else:
return num1 / num2

dict = {
"+": add,
"-": sub,
"*": muilt,
"/": div,
}

if oper in dict:
print dict[oper](num1, num2)
else:
print "error"

3.字典的遍历

favourite_places = {
"fentiao":['Xi\'an','Hangzhou'],
'laoli':['Xianyang','Hanzhong']
}

for name in favourite_places:     ##先遍历key --定义为name
print '\n' + name.title() + "\'s favourite places are"
for place in favourite_places[name]:   ##再遍历values 定义place
print place

4.集合是不重复的数据类型

集合s={1,2,3,4,5,1,2,3}

In [1]: s = {1,2,3,4,5,1,2,3}

In [2]: print type(s)
<type 'set'>

In [3]: print s
set([1, 2, 3, 4, 5])

4.1集合的定义,同元组列表一样，集合元素的数据类型不同，但不能存在列表，字典

s= {1,’hello’,’1L’,’1+3j’} 合法的集合

s= {1,’hello’,’1L’,’1+3j’,(1,2,3)} 集合里边可以存在元组

In [9]: type(s)

Out[9]: set

In [10]: print s

set([1, ‘hello’, ‘1+3j’, ‘1L’, (1, 2, 3)])

定义一个空集合s = set()

In [17]: s1 = set()

In [18]: print type(s1)
<type 'set'>

In [19]:

4.2集合的一些特性：集合是无序的数据类型，这样就不会有索引， 切片， 重复，连接这些特性，但支持成员操作符

s = {91,2,3,15,89}
print s
s.add(80)
print s

执行结果

set([91, 89, 2, 3, 15])
set([2, 3, 15, 80, 89, 91])

集合是可迭代的对象， 因此支持for循环遍历元素；

s = {91,2,3,15,89}
print s
for i in s:
print i,     ##加逗号输出不换行

执行结果：

set([91, 89, 2, 3, 15])
91 89 2 3 15        ##遍历无序

5.集合的基本操作—增加集合元素

5.1增加集合元素*.add() ###其中括号内可以是元组，字符串，基本数据类型，但不能是列表和字典

s = set()
s.add(1)
print s
s.add((1,2,3))
print s
s.add('hello')
print s

执行结果：

set([1])
set([1, (1, 2, 3)])
set([1, 'hello', (1, 2, 3)])

5.
10a88
2修改集合元素*.update() 其中括号内可以是元组，字符串，列表，但不能是字典和基本数据类型

s = set()
s.update((1,2,3))
print s
s.update('hello')
print s
s.update([3,2,6])
print s
s.update({'a','b','c'})
print s

执行结果

set([1, 2, 3])
set([1, 2, 3, 'e', 'h', 'l', 'o'])
set([1, 2, 3, 'e', 6, 'h', 'l', 'o'])
set(['a', 1, 2, 3, 'e', 6, 'h', 'c', 'l', 'o', 'b'])

5.3删除集合元素*remove()，括号内元素及其类型载集合中要存在，否则报错KeyError:

s = {1,2,3,(5,6,7)}
s.remove(1)
print s
s.remove((5,6,7))
print s

执行结果

set([3, 2, (5, 6, 7)])
set([3, 2])

5.4*.pop()随即删除集合中元素，括号内不跟参数，否则报错TypeError:

s = {1,2,3,(5,6,7)}
s.pop()
print s

执行结果

set([1, 2, (5, 6, 7)])

5.5*.discard()括号内跟集合元素，删除集合中指定元素，不加元素报错TypeError，所跟元素集合中不存在，则不操作，不报错

s = {1,2,3,(5,6,7)}
s.discard(2)
print s
s.discard((5,6,7))
print s

执行结果

set([3, 1, (5, 6, 7)])
set([3, 1])

5.6*.copy()括号不跟参数，用于集合的复制

s1 = {1,2,3}
s2=s1.copy()
print s2

执行结果

set([1, 2, 3])

6.集合的交并补差

方法一：

&    求两集合交集
|     求两集合补集
-    求两集合差题   其中-号取前集合元素
^    对等差分

实验：

s1 = {1,2,3}
s2 = {1,3,4}
print s1 & s2
print s1 | s2
print s1 - s2
print s1 ^ s2

执行结果

set([1, 3])
set([1, 2, 3, 4])
set([2])
set([2, 4])

方法二：

s1.issubset(s2)    ##判断s1是否是s2的子集，返回值布尔型
s1.issuperset(s2)  ##判断s1是否是s2的真子集，返回值布尔型
s1.difference(s2)  ##求s1和s2的集合的不同
s1.intersection    ##求s1和s2的交集
s1.union           ##求s1和s2的并集
s1.isdisjoint      ##自己看说明

s1 = {1,2,3}
s2 = {1,3,4}
print s1.intersection(s2)
print s1.union(s2)
print s1.difference(s2)

执行结果

set([1, 3])
set([1, 2, 3, 4])
set([2])

7.函数

python中如果函数无返回值， 默认返回None;

def 函数名(形参):

函数体

return 返回值

定义了一个函数

def fun(*args): # 形式参数

print args

调用函数

fun(“python”, 12, 0) # 实参

必选参数 def fun(name):

默认参数 def fun(name = “python”):

def fun(name=’python’):

print name

fun()

可变参数—-> *args args是元组类型

def fun(name,age,**kwargs): —-> **kwargs **kwargs是元组类型

print name,age, kwargs

参数组合时: 必选 > 默认参数 > 可变参数 > 关键字参数

def fun(a, b=0, *c, **d):

print a, b, c, d

fun(1, 2, 4, 5, 6, 7, c=3, x=2, z=2)

函数定义实验

#!/usr/bin/env python
# coding=utf-8
useinfo = {
'root':{
'name':'root',
'passwd':'root',
'gender':'M',
'age':'19',
'email':'qq@.com'
}
}
info = """
用户管理系统
1.注册
2.登陆
3.删除用户
4.查看用户信息
5.退出
"""
print info
def creatuser():
print "注册系统界面".center(50, "*")
username = raw_input("注册名：")
if username in useinfo:
print "%s 用户存在" % username
else:
passwd = raw_input("注册密码：")
gender = raw_input("性别M/F：")
if gender == "":
gender = None
age = raw_input("年龄：")
if age == "":
age = None
email = raw_input("邮箱:")
if email == "":
email = None
useinfo[username] = {
'name': username,
'passwd': passwd,
'gender': gender,
'age': age,
'email': email,
}

def login():
trycount = 0
while trycount < 3:
trycount += 1
print "欢迎进入登陆界面".center(50, "*")
username = raw_input("登陆用户：")
if username not in useinfo:
print "没有%s该用户，清注册" % username
break
else:
passwd = raw_input("登陆密码：")
if passwd == useinfo[username]['passwd']:
print '登陆成功'
break
else:
print '密码错误'
else:
print "密码错误输入大于3次"

def deluser():
usedel = raw_input("想删除的用户：")
if usedel not in useinfo:
print  "%s该用户不存在：" % usedel
else:
passwddel = raw_input("请输入密码：")
if passwddel not in useinfo[usedel]['passwd']:
print "删除%s该用户的密码不正确" % usedel
else:
print "删除%s用户成功" % usedel

def catuser():
usercheck = raw_input("请输入要查看用户名：")
if usercheck not in useinfo:
print "无%s用户" % usercheck
else:
cat = useinfo.get(usercheck)
print cat

while 1:
choice = raw_input("请选择：")
if choice == '1':
creatuser()
elif choice == "2":
login()
elif choice == '3':
deluser()
elif choice == '4':
catuser()
elif choice == '5':
print 'bye'
exit(0)

8.global全局变量声明

# 函数的作用域
a = 10
def fun():
a = 100
fun()
print a

执行结果为10，fun()调用时没有打印，即使打印调用输出也是None

a = 10

变量声明：

a = 10
def fun():
# # 声明a是全局变量
global  a
a = 100
# global a = 100

fun()
print a

执行结果

a = 100

9.小结

数值类型: int, long, float, complex, bool

str, list, tuple, dict, set

可变数据类型: list, dict, set 数据一旦发生变化，不会在内存中开辟一个新的存储空间来存储新的对象，如set集合

In [67]: set
Out[67]: {1, 2, 3, 9, ('A', 'a')}

In [68]: id(set)
Out[68]: 42678392

In [69]: id(set)
Out[69]: 42678392

In [70]: set
Out[70]: {1, 2, 3, 9, ('A', 'a')}

In [71]: id(set)
Out[71]: 42678392

In [72]: set.pop()
Out[72]: 3

In [73]: set
Out[73]: {1, 2, 9, ('A', 'a')}

In [74]: id(set)
Out[74]: 42678392

In [75]:

如此操作行不通，变量地址没有改变

list1 = [1,2,3,4,5]
list1[0]=10
print list1
--->>[10, 2, 3, 4, 5]
-------------------------------
d = {"a":1,"b":2}
d1=d.update(c=3)
print d1      ##印不出数据
--->>None
--------------
d = {"a":1,"b":2}
d.update(c=3)
print d      ##ok
----->>
d = {"a":1,"c":3,"b":2}

不可变数据类型：tuple,str 数据一旦发生变化，就会在内存中开辟一个新的存储空间用于存储新的对象，原来的变量名会指向一个新的存储地址,如元组t和t1

In [77]: t =(1,2,3,4)

In [78]: id(t)
Out[78]: 44086560

In [79]: t1=t[::-1]

In [80]: t1
Out[80]: (4, 3, 2, 1)

In [81]: id(t1)
Out[81]: 44086472

In [82]:

更改后的元组由于存储地址发生改变，可以赋给新的变量

t =(1,2,3,4)
t1=t[::-1]
print t1
---->>(4,3,2,1)

可迭代的数据类型:str, list, tuple, dict, set

------- 可以for循环遍历元素;

不可迭代数据类型:

------不可以for循环遍历元素;

有序的数据类型:str, list, tuple,这类数据类型支持支持索引， 切片， 连接， 重复，成员操作符特性;

无序的数据类型:set，dict, 不支持索引， 切片， 连接， 重复，仅支持成员操作符;