Python基础学习日记＜2＞

Python基础

迭代器和生成器

迭代器

关于迭代我们要知道的是:

迭代是访问元素的一种方式之一。

迭代器的特点:
1.是可以记住遍历的位置的对象
2.从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退

迭代器的两个方法：iter() 和 next()
1.iter()函数是迭代器创建对象方法
2.next() 是输出迭代器中的元素

list0=[1,2,3,4]
it=iter(list0)   #创建迭代器对象
print(next(it))    #打印出迭代器遍历到的第一个元素
print(next(it))    #打印出下一位元素
--------
1
2

我们可以看到想要打印出整个列表中元素如果一个一个打印就不太好，那么我们利用循环进行打印

利用for in循环打印列表

list0=[1,2,3,4]
it=iter(list0)   #创建迭代器对象
for x in it:
    print(x)
---------
1
2
3
4

使用**next()**函数

import sys      				#引入sys模块
list0=[1,2,3,4]
it=iter(list0)  			    #创建迭代器对象
while True:
    try:						#和Java中的trycatch
        print(next(it))
    except StopIteration:
        sys.exit()
--------------------
1
2
3
4

生成器

在Python中的生成器使用yield函数
1.生成器是一个返回迭代器的函数，只能用于迭代操作，也就是说生成器就是一个迭代器

2.调用生成器运行中，每次遇到yield时函数会暂停并保存当前所有运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续运行

3.调用一个生成器函数，返回的是一个迭代器对象

下面示例用yield实现斐波那契数列：

import sys      #引入sys模块
def fibonacci(n):       #定义函数
    a,b,counter=0,1,0
    while True:
        if(counter>n):
            return
        yield a         #有yield生成器
        a,b=b,a+b
        counter+=1
f=fibonacci(10)     #f是一个迭代器，由生成器返回生成
#利用next()函数打印
while True:
    try:
        print(next(f),end=" ")
    except StopIteration:
        sys.exit()
--------------
0 1 1 2 3 5 8 13 21 34 55 

函数

定义函数

格式:

def 函数名(参数列表):
	函数体

实例定义矩形计算面积函数

def fun(width,height):
    return width*height
w=5
h=4
print(fun(w,h))
-------
20

与c语言和Java一样而对于Python来说可以直接用def来定义函数，在c中则是没有返回值是void有返回值对应返回值数据类型

参数传递

在Python中，类型属于对象，变量是没有类型的

在Python中，string,tuples,numbers是不可更改的对象，而list,dict等则是可以修改的对象

不可变对象实例:

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)
-------------------
140712911672992
140712911672992
140712911673280

需要说明的就是id()函数是查看内存地址,相当于c语言中直接打印&a ，从上面发现对于a=1开始地址为140712911672992而当赋值为10后相当于a的地址变化，因此是不可变对象

可变对象实例：

def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
-------------------
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

必需参数

必需参数要以正确的顺序传入函数，调用的数量要和声明时的数量一致。也叫位置参数

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

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

printinfo(age=50,name='su')
printinfo(name='cs')
----------------------------
名字: su
年龄: 50
名字: cs
年龄: 5

我们可以看到在定义函数时age给了具体数值，那么在调用的时候如果不传入该参数那么就会使用默认给出的数值

不定长参数

当你调用一个函数的时候使用的范围是不同的传入的参数也是不同的，所以在你定义一个函数的时候是不确定参数到底要多少的。而不定长参数就是来解决这一问题的。
不定长参数基本语法如下:

def functionname([formal_args,] *var_args_tuple ):
 	  "函数_文档字符串"
 	  function_suite
	   return [expression]

1. *的参数是以元组（tuple）的形式导入，存放所有未命名的变量参数。

def printinfo(a,*b):
    print("输出: ")
    print(a)
    print(b)
    return
printinfo(1,2,3,4)
printinfo(1,1)
----------------
输出: 
1
(2, 3, 4)
输出: 
1
(1,)

要知道对于a往后的参数存在的形式是元组(tuple)

2. 当参数变为**时候，那么参数则会以字典的形式存在导入

def printinfo(a,**b):
    print("输出: ")
    print(a)
    print(b)
    return
printinfo(1,g0=2,g1=3,g2=4,g3=5)
printinfo(1,k=1)
-------------------------
输出: 
1
{'g0': 2, 'g1': 3, 'g2': 4, 'g3': 5}
输出: 
1
{'k': 1}

3. 如果*单独出现的话，出现*后的参数必需用关键字传入

def f(a,*,b,c):
    return a+b+c
print(f(3,1,2))			#会报错必须有关键字
print(f(3,b=1,c=2))			#正确的形式
---------------------------
6

匿名函数

要使用匿名函数就要用关键字lambda来创建匿名函数,语法如下:

lambda [arg1 [,arg2,.....argn]]:expression

1. lambda是一个表达式，比用def定义简单点
2. lambda表达式仅仅能处理一些简单的函数表达

sum=lambda a,b:a+b
print(sum(1,1))
print(sum(100,1))
------------------
2
101

return语句

c语言和Java中都有关键字return，而return则是用于退出函数

def sum(a,b):
    t=a+b
    print("函数内:",t)
    return t
t=sum(1,1)
print("函数外:",t)
------------------
函数内: 2
函数外: 2