绪论
本篇文章既上篇文章之后为大家带来的是关于Python3中一些基础的知识点，通过上篇的学习，我们队Python3中的一些基本的语法有所了解和掌握。
** 主要内容的介绍**
- 字典的介绍
- 字典的运用
- 元组的介绍
- 元组的应用
- 函数的介绍
- 函数的应用
** 1、字典（dict）的介绍**
为什么会有字典类型的出现？我们都知道Python3是一门高级动态编程语言，对于高级语言设计来说，功能理应很多，为我们开发者减少更多的压力和负担，比如，现在我们需要去存储一个学员的相关信息，包括姓名、电话、QQ、家庭地址等等，那么利用我们以前学的知识，也可以做，比如，我们可以用列表去完成，通过列表进行存储，但是，这样在需要用的时候，取的时候只能根据下标去拿，很麻烦，所以Python3开发者为了更好的被别人所用，那么就出现了字典类型。
** 1.1字典定义格式**
例如： names = {'name':'laowang','age':26,'address':'chongqing'}
这就是定义了一个字典，格式：
变量名称（字典名称） = {key-value}
采用的是键值对的形式进行存储，通过键（key）去拿到值
比如： name = names['name'] 那么得到的结果就是 name = laowang
字典进行取出值的时候，和列表有点不同，是通过key进行找到value。
** 1.2字典的常见操作**
字典的元素增加：
例如：names = {}#这是定义了一个空的字典，
In [2]: names = {}
In [3]: print(names)
{}
In [4]: names['name'] = 'laowang'
In [5]: names
Out[5]: {'name': 'laowang'}
In [6]: names['age'] = 27
In [7]: print(names)
{'age': 27, 'name': 'laowang'}
In [8]:
字典添加元素的时候，需要注意一点就是，如果字典里原来有key，那么在次添加时，会覆盖以前key所对应的值，
例如，把上面例程的names在次修改：
names['name'] = 'laozhao'
In [9]: names
Out[9]: {'age': 27, 'name': 'laozhao'}
可以看到names这个字典里的内容发生了改变
字典的查找元素
对应字典的查找元素，就是通过key来进行直接查找或者间接的查找get()
上示例代码：
一般查询，我们还是利用get()这个函数，因为这个如果查找没有，程序是不会崩溃的。
字典元素的修改
对于字典元素的修改，这里就不说了，就是通过key进行重新赋值，上面添加元素的时候就展示了。
删除字典的元素
对于删除字典的元素，其实和列表删除元素类似，
语法就是 del 字典名[key] 得到的是一个新的字典。
还有删除也可以用pop()或者popitem()，这里就不演示了。
#字典元素的删除
In [18]: dict_name
Out[18]: {'age': 23, 'address': 'guizhou', 'name': 'laowang'}
In [19]: del dict_name['name']
In [20]: dict_name
Out[20]: {'age': 23, 'address': 'guizhou'}
In [21]: a = [11,22,44]
#列表的元素删除
In [22]: a
Out[22]: [11, 22, 44]
In [23]: del a[1]
In [24]: a
Out[24]: [11, 44]
2、字典的常见函数运用
len()
对于这个，我相信大家并不陌生，就是求元素的个数
例如： dict_a = {'key1':23,'key2':24,'key3':35}
len(dict_a) => 返回的是一个int类型的值，即字典里键值对的个数，2
keys()
得到的就是所有的键值对中的键的值，
In [49]: names = {'name':'laowang','age':23}
In [50]: names.keys()
Out[50]: dict_keys(['age', 'name'])
values()
得到的就是字典中所有的值。
In [51]: names
Out[51]: {'age': 23, 'name': 'laowang'}
In [52]: names.values()
Out[52]: dict_values([23, 'laowang'])
items
得到的是字典中所有的键值对
In [57]: names
Out[57]: {'age': 23, 'name': 'laowang'}
In [58]: names.items()
Out[58]: dict_items([('age', 23), ('name', 'laowang')])
当然，字典的操作还有很多，这里就不一一介绍了，学习的过程就是自己要去举一反三。
补充
以前，我们提过两种循环，其中有一种就是for循环，对于for循环，在这里做一个知识点的补充，就是for else 的用法，看示例代码
#coding=utf-8
a = [11,22,33,44]
for temp in a:
print(temp)
else:
print('====zhixing====')
#执行的结果：
11
22
33
44
====zhixing====
解释：就是在for循环执行后，这个else里的语句也要被执行，这个就是for else 的联用，这个语法是在其他高级语法中没有的，
a = [11,22,33,44]
for temp in a:
print(temp)
break
else:
print('====zhixing====')
#执行结果：
11
解释：这是因为在for循环中，如果有break，那么else中的代码是永远也不执行的，当然实际运用需要结合自己的需求。
2、元组(Tuple)
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
#定义一个元组
names = (11,22,33,44)
#访问元组里元素
print(names[0])
#输出的结果就是11，
元组的一些操作
元组的count和index内置函数
>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')#返回的是元组里有多少个这个元素
2
>>> a.count('d')
0
补充：字符串、列表、元组、字典一些共有的操作
1、运算符的操作
a、+
对于列表、元组、字符串相加，就相当于合并
[1,2]+[3,4] = [1,2,3,4]
b、也是对于列表、字符串、元组来讲
对于就相当于复制
'hi'*4 = 'hihihihi'
c、in 元素是否存在
针对的是列表、元组、字符串、字典
比如：3 in [2,3,4,5] 返回值是True
d、not in 判断元素是否不存在
比如： 4 not in[1,2,3,5,6] 返回值是True
基础语法就讲这么多了，那么后面更高级的语法将会在后面的高级程序里讲解，
函数
函数就是把一些功能模块进行一个封装，让实现的功能进行独立，需要使用的时候进行函数的调用而已。在Python3中的函数其实和C语言中的函数都是差不多相同的，并没有什么区别。
1、无返回值，无参数
def test():
print('This is test')
test（）
声明函数用关键字 def ，其中test是函数的名称 ，（）里面是没有参数的，上面的示例就是声明了一个无返回值、无参数的值。
2、无返回值、有参数
def test1(a,b):
result = a + b
print(result)
test1(11,22)
#打印结果为33
3、有返回值、无参数
def test2():
return 20
result = test2()
print(result)
#输出结果为20
函数有返回值，就使用return 进行返回
4、有返回值、有参数
def test3(a , b):
result = a * b
sum_num = a + b
return result,sum_num
result,sum_num = test3(11,10)
print（result）
print(sum_num)
#程序运行结果：110 21
这里程序返回值的时候，返回的是多个值，这个语法是在Python中独有的语法，其他高级语法是没有的，那么这里是返回的多个字，这些值是本质是通过一个元组进行存储的，当然，你可以打印看看就知道了。
函数应用的简单介绍
>>> def sum_num():
i = 1
sum = 0
while i <= 100:
sum +=i
i+=1
return sum
>>> res = sum_num()
>>> print(res)
5050
只有你想做的功能模块，都可以采用函数进行一个封装
补充：函数的参数问题
1、函数缺省参数
def printinfo( name, age = 35 ):
# 打印任何传入的字符串
print "Name: ", name
print "Age ", age
# 调用printinfo函数
printinfo(name="miki" )
printinfo( age=9,name="miki" )
#程序输出的结果：
Name: miki
Age 35
Name: miki
Age 9
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。而函数默认值的参数必须跟在函数参数的最后面，举一个例子
>>> def printinfo(name, age=35, sex):
... print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument
2、不定长参数
有的时候可能需要一个已经声明的函数处理更多的参数时，那么这个函数在声明的时候就不能把参数进行写死了，所以就出现了不定长参数，对于不定长参数类的函数，格式：
def functionname([formal_args,] *args, **kwargs):
"函数_文档字符串"
function_suite
return [expression]
说明一下：加了星号（）的变量args会存放所有未命名的变量参数，args为元组；而加*的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。
In [1]: def fun(a,b,*args,**kwargs):
...: print(a)
...: print(b)
...: print(args)
...: print(kwargs)
...:
In [2]: fun(11,22,33,44,55,i = 10,j = 20,k = 30)#注意传参的对应
11
22
(33, 44, 55)
{'i': 10, 'j': 20, 'k': 30}
In [3]:
大家可以看到一个输出结果，当你传的参数是很长的一串的时候，那么在函数的形参中是怎么进行对应的呢，首先满足直接形参，a = 11,b = 22,然后剩下的未命名参数，就全部传给args,并且args是一个元组，同理而加的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。
其实这个不难理解，大家有C语言的知识就应该明白，args其实就是一个指针而已，这个指针指向的是元组的首地址而已，而*kwargs他只不过这里他为了区分，是以字典的形式进行保留的。
那大家可能会问，这个东西怎么取出来呢？其实很简单的，元组和字典我们都可以采用遍历的。这里就展示了。
3、引用传参
在Python中并没有想C语言一样，有指针的形式传参，那么它是怎么做到想C语言那样的呢，那就是引用传参。
在说引用传参的时候，传递的参数，要分是可变类型和不可变类型，在Python中，不可变类型是字符串、数字、元组等，可变的类型有列表和字典。
>>> def selfAdd(a):
... """自增"""
... a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]
Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。
总结
在这里简单的介绍了python的相关语法，对于元组、列表、数组、函数都是需要大量的练习。后面讲讲解有关Python的文件操作。
