python学习笔记（一）

1、最基本的IO语句

 name=input()

 print('hello,',name)

 

2、python还允许用r''表示''内部的字符串默认不转义

print('\\\t\\')

print(r'\\\t\')

 

3、空值用none表示，但不能理解为0。因为0是有意义的。

4、java是静态语言，在定义变量时必须指定变量类型。python是动态语言，更灵活。

5、a='abc'

     b=a

     a='xyz'

     print(b)

     表示把变量b指向变量a指向的数据,打印变量b的结果为'abc'。

6、ascii 编码是一个字节，unicode编码是二个字节，UTF-8编码比较节省空间。

     计算机内存中统一使用unicode编码，当保存到硬盘或者传输时候转化为UTF-8编码。

     在python3以上的版本中，字符串是以unicode编码的。

 7、

>>> s1=72
>>> s2=85
>>>r=(s2-s1)/float(s1)*100

>>> print('%.1f%%' %r)
18.1%

 

 8、tuple不可变，尽量用tuple代替list。在定义tuple时候，tuple的元素必须被确定下来。

 

9、

 

10、

11、

练习

小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

• 低于18.5：过轻
• 18.5-25：正常
• 25-28：过重
• 28-32：肥胖
• 高于32：严重肥胖

用if-elif判断并打印结果：

height=float(input('请输入身高'))
weight=float(input('请输入体重'))
bmi=weight/(height**2)
if bmi<18.5:
    print('bmi是%.2f, 过轻'%bmi)
elif bmi>=18.5 and bmi<=25:
    print('bmi是%.2f 正常'%bmi)
elif bmi>25 and bmi<=28:
    print('bmi是%.2f, 过重'%bmi)
elif bmi>28and bmi<=32:
    print('bmi是%.2f, 肥胖'%bmi)
else:
    print('bmi是%.2f,严重肥胖'%bmi)

 

12、

练习

请利用循环依次对list中的每个名字打印出Hello, xxx!：

# -*- coding: utf-8 -*-
L = ['Bart', 'Lisa', 'Adam']

 for x in L:
    print('hello,',x)

 for x in L:
    print("hello,%s"%x)



13、dict字典用法   dict的key是不可变对象。list不能作为key，字符串和整数可以作为key。

>>> d={'mic':95,'bob':75,'tra':85}  #初始化字典
>>> d['mic']                        #通过key显示value
95
>>> d['tta']=96                     #增加字典元素
>>> d                               #显示字典元素
{'mic': 95, 'tta': 96, 'tra': 85, 'bob': 75}
>>> d.pop('bob')                    #删除字典元素 
75
>>> d
{'mic': 95, 'tta': 96, 'tra': 85}

14、




15、对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。
相反，这些对象会创建新的对象并返回。这样就保证了不可变对象本身是永远不会被改变的。

16、


17、

18、

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

19、
如果利用可变参数，调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

所以，我们把函数的参数改为可变参数：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。


20、

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

 

21、

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。

22、默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

       

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数不要忘了写分隔符*，否则定义的将是位置参数。

 

23、递归函数原理

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。