adam函数 python_Python学习笔记

Python学习笔记

一、数据类型

1、整数 2、浮点数3、字符串4、布尔值5、空值

二、print语句

链接 >>> print 'The quick brown fox', 'jumps over', 'the lazy dog'

The quick brown fox jumps over the lazy dog

三、raw字符串与多行字符串

print '\"To be, or not to be\": that is the question.\nWhether it\'s nobler in the mind to suffer.'

print r'''"To be, or not to be": that is the question.Whether it's nobler in the mind to suffer.'''

四、Unicode字符串

# -*- coding: utf-8 -*-      print u'中文'

五、List(列表)的操作

定义：>>> classmates = ['Michael', 'Bob', 'Tracy']    print classmates

顺序访问：L = [95.5,85,59,59]      print L[0]   95.5

倒序访问：L = [95.5,85,59]      print L[-1]   59

添加：1、append()方法，追加到list的末尾

>>> L = ['Adam', 'Lisa', 'Bart']

>>> L.append('Paul')

>>> print L

['Adam', 'Lisa', 'Bart', 'Paul']

2、insert()方法，可以最近到指定地点

>>> L = ['Adam', 'Lisa', 'Bart']

>>> L.insert(0, 'Paul')

>>> print L

['Paul', 'Adam', 'Lisa', 'Bart']

删除：1、pop()方法默认从list尾部删除一个元素

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L.pop()

'Paul'

>>> print L

['Adam', 'Lisa', 'Bart']

2、>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']

>>> L.pop(2)

'Paul'

>>> print L

['Adam', 'Lisa', 'Bart']

替换：>>> L = ['Adam', 'Lisa', 'Bart']

>>> L[2] = 'Paul'

>>> print L

L = ['Adam', 'Lisa', 'Paul']

六、创建tuple(元组)

tuple 和list非常类似，但是，tuple一旦创建完毕，就不能修改了。

创建tuple和创建list唯一不同之处是用( )替代了[ ]，其他操作基本都一致。

单元素tuple为了避免歧义，规定定义 >>> t = (1,)    >>> print  t     (1,)

可变tuple>>> t = ('a', 'b', ['A', 'B'])    注意到t有3个元素：'a'，'b'和一个

list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过t[2] 拿到：>>> L = t[2]

七、if语句

Python代码的缩进非常严格，具有相同缩进的代码被视为代码块，

缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

if 语句后接表达式，然后用:表示代码块开始。

如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车：

age = 20

if age >= 18:

print 'your age is', age

print 'adult'

print 'END'

If-else语句

if age >= 18:

print 'adult'

else:

print 'teenager'

If-elif-else语句

score = 85

if score>=90:

print 'excellent'

elif score>=80:

print 'good'

elif score>=60:

print 'passed'

else:

print 'failed'

八、for循环

L = [75, 92, 59, 68]

sum = 0.0

for score in L:

sum = sum + score

print sum / 4

九、while循环

和 for 循环不同的另一种循环是while循环，while循环不会迭代list或tuple的元素，而是根据表达式判断循环是否结束。

利用while循环计算100以内奇数的和

sum = 0

x = 1

while x < 100:

sum = sum + x

x = x + 2

print sum

十、break退出循环

用 for 循环或者while循环时，如果要在循环体内直接退出循环，可以使用break语句。

利用 while True 无限循环配合break语句，计算1 + 2 + 4 + 8 + 16 + ...的前20项的和。

sum = 0

x = 1

n = 1

while True:

sum = sum + x

x = x * 2

n = n + 1

if n > 20:

break

print sum

十一、Continue

对已有的计算 0 - 100 的while循环进行改造，通过增加continue语句，使得只计算奇数的和：

sum = 0

x = 0

while True:

x = x + 1

if x > 100:

break

if x % 2 == 0:

continue

sum = sum+ x

print sum

十二、多重循环

对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23(2 < 3)

for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]:

for y in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:

if x < y:

print x * 10 + y

十三、Dict

我们把名字称为key，对应的成绩称为value，dict就是通过key来查找value。

花括号 {} 表示这是一个dict，然后按照key: value,写出来即可。最后一个key: value的逗号可以省略。

由于dict也是集合，len()函数可以计算任意集合的大小：

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

十四、访问dict

1、if 'Paul' in d:

print d['Paul']  通过key访问，返回value值

2、通过dict本身提供的get方法

>>> print d.get('Bart')

59

>>> print d.get('Paul')

None          没有key值时，返回None

十五、dict的特点

1、查找速度快

无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

由于dict是按key查找，所以，在一个dict中，key不能重复。

2、存储的key-value序对是没有顺序的

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

当我们试图打印这个dict时：

>>> print d

{'Lisa': 85, 'Adam': 95, 'Bart': 59}

打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。

3、作为 key 的元素必须不可变

Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为key。但是list是可变的，就不能作为key。

十六、更新dict

1、key值不同，新添加，用赋值语句：>>> d['Paul'] = 72

2、如果key值已有，则更新，覆盖原有

十七、遍历dict

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

for key in d:

print key + ':', d.get(key)

十八、Set

dict的作用是建立一组key和一组value的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的key，不关心key对应的value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和 dict 的key很像。

创建 set 的方式是调用set()并传入一个list，list的元素将作为set的元素：

打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。

因为set不能包含重复的元素，所以，当我们传入包含重复元素的list会怎么样呢？

十九、访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。

>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])

>>> 'Bart' in s

True

>>> 'Bill' in s   大小写敏感

False

二十、set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

最后，set存储的元素也是没有顺序的。

months = set(['Jan','Feb','Mar','Apr','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])

x1 = 'Feb'

x2 = 'Sun'

if x1 in months:

print 'x1: ok'

else:

print 'x1: error'

if x2 in months:

print 'x2: ok'

else:

print 'x2: error'

二十一、遍历set

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for x in s:

print x[0] + ':', x[1]

Lisa: 85

Adam: 95

Bart: 59

二十二、更新set

1、添加新的元素

>>> s = set([1, 2, 3])

>>> s.add(4)

>>> print s

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

2、删除set中的元素      如果删除的元素不存在set中，remove()会报错：

>>> s = set([1, 2, 3, 4])

>>> s.remove(4)

>>> print s

set([1, 2, 3])

二十三、函数

写一次，多次调用

调用函数  绝对值的函数 abs

比较函数 cmp(x, y) 就需要两个参数，如果xy，返回1

int()函数可以把其他数据类型转换为整数

str()函数把其他类型转换成str

sum()函数接受一个list作为参数，并返回list所有元素之和。请计算1*1 + 2*2 + 3*3 + ...+ 100*100。

L = []

x = 1

while x <= 100:

L.append(x * x)

x = x + 1

print sum(L)

二十四、编写函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

请定义一个 square_of_sum 函数，它接受一个list，返回list中每个元素平方的和

def square_of_sum(L):

sum = 0

for x in L:

sum = sum + x * x

return sum

print square_of_sum([1, 2, 3, 4, 5])

print square_of_sum([-5, 0, 5, 15, 25])

返回多值

用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起

来更方便。一元二次方程的定义是：ax2+ bx + c = 0

请编写一个函数，返回一元二次方程的两个解。

注意：Python的math包提供了sqrt()函数用于计算平方根。

import math

def quadratic_equation(a, b, c):

t = math.sqrt(b * b - 4 * a * c)

return (-b + t) / (2 * a),( -b - t )/ (2 * a)

print quadratic_equation(2, 3, 0)

print quadratic_equation(1, -6, 5)

二十五、递归函数

汉诺塔 (http://baike.baidu.com/view/191666.htm) 的移动也可以看做是递归函数。

我们对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为：

如果a只有一个圆盘，可以直接移动到c；

如果a有N个圆盘，可以看成a有1个圆盘(底盘)+ (N-1)个圆盘，首先需要把(N-1)个圆盘移动到 b，然后，将a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。

请编写一个函数，给定输入 n, a, b, c，打印出移动的步骤：

move(n, a, b, c)

例如，输入 move(2, 'A', 'B', 'C')，打印出：

A --> B

A --> C

def move(n, a, b, c):

if n == 1:

print a,'-->',c

return

move(n-1,a,c,b)

print a,'-->',c

move(n-1,b,a,c)

move(4, 'A', 'B', 'C')

B --> C

定义默认参数

int()函数的第二个参数是转换进制，如果不传，默认是十进制(base=10)，如果传了，就用传入的参数。

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：

# OK:

def fn1(a, b=1, c=2):

pass

# Error:

def fn2(a=1, b):

Pass

def greet(name='world'):

print 'Hello,' + name + '.'

greet()

greet('Bart')

Hello,world.

Hello,Bart.

定义可变参数

可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个tuple就好了。

可变参数 args 是一个tuple，当0个参数传入时，args是一个空tuple。

参考代码:

def average(*args):

sum = 0.0

if len(args) == 0:

return sum

for x in args:

sum = sum + x

return sum / len(args)

print average()

print average(1, 2)

print average(1, 2, 2, 3, 4)

二十六、对list进行切片Slice

取前3个元素，用一行代码就可以完成切片：

>>> L[0:3]

['Adam', 'Lisa', 'Bart']

只用一个 : ，表示从头到尾：

>>> L[:]

['Adam', 'Lisa', 'Bart', 'Paul']

请利用切片，取出：

1. 前10个数；

2. 3的倍数；

3.不大于50的5的倍数。

L = range(1, 101)

print L[:10]

print L[2::3]

print L[4:50:5]

倒序切片

5的倍数可以用::5取出，要确定起始索引。

参考代码:

L = range(1, 101)

print L[-10:]

print L[-46::5]

二十七、对字符串切片

但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。

def firstCharUpper(s):

return s[0].upper() + s[1:]

print firstCharUpper('hello')

print firstCharUpper('sunday')

print firstCharUpper('september')

Hello

Sunday

September

二十八、迭代

因为 Python 的for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。

因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：

1. 有序集合：list，tuple，str和unicode；

2. 无序集合：set

3. 无序集合并且具有key-value对：dict

而迭代是一个动词，它指的是一种操作，在Python中，就是for循环。

迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。

请用for循环迭代数列1-100并打印出7的倍数。

for i in range(1,101):

if i % 7 == 0:

print i