Python自学：菜菜子混乱的笔记03——函数、数据结构、模块

Python的函数

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

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

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

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

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

一个简单的例子

def hello():
    print("你好，世界~")

hello()

又一个简单的例子

def max(a,b):
    if(a>b):
        return a
    else:
        return b

a=4
b=9
print(max(a,b))

双一个简单的例子

# 计算面积的函数
def area(width,height):
    return width*height

#输出“欢迎”的函数
def print_welcome(name):
    print("welcome"+name,"!")

print_welcome("菜菜子丫")
w=2
h=9
print("面积为：",area(w,h))

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

一个例子：不可变类型

# 不可变对象
def change(a):
    print(id(a))
    a=10
    print(id(a))

a=1
print((a))
change(a)
print("从函数出来之后：",(a))

又一个例子：可变类型

def changeme(mylist):
    n=10
    i=1
    while i<=n:
        mylist.append(i)
        i+=1
    print("函数内取值：",mylist)
    return

#调用changeme函数
mylist=[10,20,30]
changeme(mylist)
print("函数外取值：",mylist)

参数调用方式

必须参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样：
参见第一个例子（如果不传入参数，则会报错）

关键字参数
以下实例中演示了函数参数的使用不需要使用指定顺序：

def printinfo(name,age):
    print("名字：",name)
    print("年龄：",age)
    return

printinfo(age=100,name="雪莉")

默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

def printinfo(name="雪莉",age=100):
    print("姓名：",name)
    print("年龄：",age)
    return

printinfo("苦艾酒","?")
print("---------------")
printinfo(age=18,name="安吉")

不定长度参数

1）加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

#不定长度的参数：
def fun(arg,*vartuple):
    "打印任何传入的参数"
    print("输出：")
    print(arg)
    print(vartuple)

fun(40,100,100,111,1,2,4,)

结果：
输出：
40
(100, 100, 111, 1, 2, 4)

2）加了两个星号 ** 的参数会以字典的形式导入

def printy(arg,**vardict):
    "打印任何传入的参数"
    print("输出")
    print(arg)
    print(vardict)
    return

printy(1,a=2,b=4)#发现这里a,b位置不可以是数字

Python数据结构

1、列表
列表的一些基本用法：

# Python的列表是可变的，且功能多样

#.count(x),返回列表中x出现的个数
a=[66.25,333,333,1,1234.5]
print(a.count(333),a.count(1),a.count(11111))

# .insert(i,x):在第i个元素前面添加元素x,.append(y):在列表末尾添加元素x
a.insert(2,900)
a.append("wo")
print(a)

#.index(x)返回x的下标,第一个x的下标号
print(a.index(333))
#.remove(x)：移除x，移除第一个333
a.remove(333)
print(a)
#.reverse()：逆置
a.reverse()
print("逆置",a)
#.sort():排序，从小到大
a.remove("wo")
a.sort()
print("排序：",a)

还可以将列表当作堆栈使用：手感和C++一样一样的~

stack=[3,4,5]
stack.append(6)
stack.append(7)
print(stack)
stack.pop()
print(stack)

还还可以将列表当作队列使用：
只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。老慢了

from collections import deque
queue=deque(["Eric","John","Michael"])
queue.append("Terry")
queue.append("Grama")
#添加还是添加到队列末尾
print(queue)
#删除是删除第一个
queue.popleft()
print(queue)

你以为这就结束了？
不不不~
下面介绍一下懒人专用 列表推导式：

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

vec=[1,2,3,4]

a=[3*x for x in vec]
print(a)

b=[[x,x**2] for x in vec]
print(b)

freshfuit=['  banana', '  loganberry ', 'passion fruit  ']
c=[weapon.strip()+'s' for weapon in freshfuit]#读取字符串的方式
print(c)

d=[[x,x**2] for x in vec if x>3]#if可以用作过滤器
print(d)

关于将34的矩阵转化为43的矩阵之所以加粗显示是因为这个知识点还是蛮重要的2233333

matrix34=[
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
]
#方法一：
matrix43=[[row[i] for row in matrix34] for i in range(4)]
print(matrix43)

#方法二：
transpose=[]
for i in range(4):
    transpose.append([row[i] for row in matrix34])
print(transpose)

当然，还有第三种方法，不过我觉得前两种比较简单，够用了哈~

顺便补充一下del的应用

a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
print(a)
del a[2:4]
print(a)
del a[:]
print(a)

如果del a的话，就是删除变量了，再print(a)就报错了~

2、元组和序列

t = 12345, 54321, 'hello!'
print(t[0])
print(t)
u=t,(1,2,3,4,5),5,6,7
print(u)

元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）

3、集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典

其实这个知识点在之前的笔记里面有提过~这里不赘述了
补充一下上一次没有记下的知识点：
集合也支持推导式~~

a={x for x in 'asdfghjhgzndgbsgsbdj' if x not in 'abc'}
print(a)

4、字典

另一个非常有用的 Python 内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：{}

这个知识点之前也有讲过，这里主要补充一下字典的键转成单独的列表的例子：

tel={'jack':4098,'space':1823}
print(tel)
tel['me']=12345
print(tel)

del tel['space']

#将字典中的键转成列表
a=list(tel.keys())
print(a)
#将字典中的键转换成列表（排序）
b=sorted(tel.keys())
print(b)

构造函数 dict() 直接从键值对元组列表中构建字典
此外，字典推导可以用来创建任意键和值的表达式词典
如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便

n1=dict([('space',123),('wer',456),('spass',890)])
print(n1)

n2={x:x**2 for x in (1,2,3)}
print(n2)

n3=dict(we=1,are=2,family=3)
print(n3)

Python模块

就是上面介绍的玩意儿~
略哈哈哈
介绍一下遍历技巧吧，确实也是经常用的：

在字典中遍历时：
关键字和对应的值可以使用 items() 方法同时解读出来：

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k,v in knights.items():
    print(k,v)

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
皮一下，如果作用到字典上面，返回的是索引位置以及键值
例子还是作用在序列上的例子啦~~

knights = ['tic', 'tac', 'toe']
for i,v in enumerate(knights):
    print(i,v)

反向遍历
这里介绍一下reversed()函数

for i in reversed(range(1, 10, 2)):#定义序列1-10，间隔为2
      print(i)

多个序列遍历（啊哈哈，脚踏两只船的赶脚）
实践表明，在这种情况下，如果两个列表元素个数不相等，那么会选择个数比较少的那个作为最终的迭代次数

question=['name','quest','favorite color']
answers=['lancelot','the holy grail','blue','www']
for q,a in zip(question ,answers):
    print('what is your{0}? it is {1}'.format(q, a))

按大小顺序遍历序列，并且去重复

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)

去掉set()的话，就会有重复元素反复横跳啦~