python入门语法

if -else 语句

 

语句与C语言类似，但是缩进为4个字符，如下仍有其他语句，依旧缩进直到if 结束。

if判断结果为Ture 或者False 时 分别执行if和else中的语句

>>> a=55

>>> if a>60:

...     print 'passed'

...     print 'good'

... else:

...     print 'failed'

...     print 'bad'

...

failed

bad

else与if后都有：

if-elif-else语句

if-elif-else== if- else if- else

与C中if() else if()  else()相同

score = 85

if score>=90:

    print 'excellent'

elif score>=80:

    print 'good'

elif score>=60:

    print 'passed'

else:

    print 'failed'

for 语句

迭代对象集合

与C中不同，python中的for并非是指示循环执行有限次，可以迭代中对象集合的项目。对象集合可以是任何 Python 容器类型，包括tuple、string 和 list 类型。

>>> tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

>>> count = 0

>>> for num in tuple :

...   count += num

... else:

...   print count

 

 

 

 

 

                          

 

>>> mylist = [1, 1.0, 1.0j, '1', (1,), [1]]

>>> for item in mylist :

...   print item, "\t", type(item))

 

 

 

>>> st = "Python Is A Great Programming Language!"

>>> for c in st:

...   print c,

...

P y t h o n  I s  A  G r e a t  P r o g r a m m i n g  L a n g u a g e !

 

 

 

 

 

注意：for后在循环内的语句，首行仍需要缩进4个字符。

 

Python 中也可用for循环完成对语句操作特定次的操作

Python for 循环可以通过使用内置的 range 和 xrange 方法来模拟该行为。

 

>>> r = range(10)

>>> print r

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> type(r)

<type 'list'>

 

 

>>> xr = xrange(10)

>>> print xr

xrange(10)

>>> type(xr)

<type 'xrange'>

首先演示了 range 方法，它创建一个包含一系列整数的新 list。调用 range 方法的一般形式是提供单个值，用作整数 list 的上限。零为起始值。因此，调用 range(10) 将创建包含整数 0 至 9（包含 9）的 list。range方法接受起始索引以及步长。所以，调用 range(11,20) 将创建从 11 至 19（包含 19）的整数 list，而调用 range(12, 89, 2) 将创建从 12 至 88 的偶数 list。

由于 xrange 方法也创建整数 list（其使用相同参数），所以它与 range 方法非常相似。但是，xrange 方法仅在需要时才在 list 中创建整数。例如，尝试打印出新创建的 xrange 时除了 xrange 的名称，不会显示任何数据。当需要迭代大量整数时，xrange 方法更适用，因为它不会创建极大的 list，那样会消耗大量计算机内存。

type() 函数是打印对应的数据类型eg. type(r) <type ‘list’> 意为r的数据类型是list。

 

while 语句

  与C语言大致相同：while x < N : 每次循环先判断，若结果为Ture，则执行循环体代码块，否则退出循环。

break 语句

while Ture:

    print x

x = x + 1

if x>20

    break

break语句与while语句与if语句一起使用。

 

 

 

 

 

continue 语句

while True:

    x = x + 1

    if x > 100:

        break

    if x%2==0:

        continue

    sum=sum+x

print sum

在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

函数

调用函数：

https://docs.python.org/2/library/functions.html#abs

可以查看python 的所有内置函数，或者可以通过内置的交互式命令 help(函数名)查看函数的使用。

 

编写函数：

函数定义要用def 语句，依次写出函数名，括号，括号里的参数和冒号，在缩进块中编写函数，返回值用return 语句。

def square_of_sum(L)：

sum = 0

for x in L：

    sum = sum + x*x

    x=x+1

return sum

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

>>>55

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。

return None可以简写为return。

 

函数返回很多值：

函数返回很多值，其实返回的是一个tuple。

递归函数：

递归函数与C语言中的递归函数相同，但是比C中的函数更简洁。

用一个例子来说明——汉诺塔：

我们将柱子命名为A B C，将所有圆盘从A移动到C。

Move (n, a, b, c):

if a==1:

    print a, ’à’ , c

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

print a, ’à’ , c

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

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

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

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

1.      如果A柱上只有一个圆盘，则为最大的一个，所以直接移动到C。

2.      将n-1个圆盘移动到B，所以调整括号中柱子的顺序。

3.      将n-1个移动过之后，将最大的移动到C

4.      再将n-1个从B移动到C

Move (n, a, b, c)

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

A --> B

A --> C

B --> C

递归函数的作用就是让移动的过程的代码变得简单。

先将N-1 圆盘从A移动到B再把最大的盘子移动到A，

再将N-1个盘子移动到C。

Move(n, a, b,c)表示将n个柱子从A移动到C。

定义默认参数:  int()函数可以接受两个参数的输入。

>>>int（‘123’，8）  第二个输入的为进制转换，如果不输入默认为十进制

83

def greet (x=’world’):

print ‘hello,’ ,x,’ . ’

greet ()

greet (‘Bart’)

输出的结果：

hello，world .

hello，Bart .

默认参数的作用是简化参数。你只需要把必须的参数传进去，但是在需要的时候，又可以传入额外的参数覆盖默认参数值。

 

定义的可变参数：

 def fn(*args):

python解释器会把输入的参数组装成一个tuple传递给可变参数。因此args参数其实就是一个tuple。

List和list切片

List像是C中的数组，list中的元素按顺序排列，可以通过索引（下标）来确定list中的元素，但是有区别的是C的索引只能是正数，但是list可以用负数来表示反向索引。对于一个含3个元素的索引来说，list[2] = list [-1]。

添加新元素：

用append()函数，只接受一个参数，可以把新元素加到末尾，insert()函数，接受两个参数，可以把新元素加入到指定位置。

删除/替换元素：

用pop()函数，接受指定元素的索引，当无输入时删除。

替换元素直接可以将对应元素直接赋值。

List切片：

L = range ( 1 , 101 )

print L [ 0 : 10 ]

print L [ 2 : 101 : 3 ]

print L [4 : 50 : 5 ]

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
>>> [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

顾名思义，切片就是将list中指定部分切割下来，切片接受3个参数 。 

1.     start 2. end3. Interval     

 [ 起点：终点：间隔 ]

起点/终点：起点/终点序号与数组元素下标相同（0为第一个元素下标）。

间隔：每隔多个元素取一个元素（5代表每隔5个元素取一个元素）。

 

倒序切片：

List中的元素可以通过倒序访问，所以切片同样也可以通过倒序来访问。

倒序中-1为倒数第一个数，以此类推。

对字符串切片：

字符串也可以看成一种list，每个元素就是一个字符。切片方法相同。

 

Dict和set

Dict：key-value，通过key对应查找value的储存结构。与list不同的是，list的“key”是下标，而dict的下标是key。用花括号{}表示是一个dict，然后按照key：value的格式写出来就可以，两两之间用“，”隔开。

访问dict：

访问与list类似，list中访问：L[0]，dict 中访问：d[“key”]。

特点：

第一个特点dict具有查询速度快，查询速度不因为dict的数量而变化，类似C中的直接访问储存元素的地址，而key就是地址。但是key不能重复，就像地址一样，一个地址只能住一个元素，不能住第二个元素。

第二个特点就是dict的元素储存是无序的，list是有序的而dict是无序的。

Dict的缺点：占用空间很大，会浪费很多空间，list正好相反占用空间小，但是查询速度慢。

Dict的更新：

使用赋值语句d[‘a’]= 75 如果key(a)不存在，则重新建立一个空间，如果存在则替换调原来的value。Dict的迭代也可以同时迭代key和values，使用不同的函数。

Dict的迭代：

1.     迭代values：可以使用values()的函数，将dict中的所有values传入一个list中.

2.     除过values()函数以外，还有itervalues()函数，两者效果相同，但是itervalues()函数并非另辟空间list传入values，而是直接取出，所以比values()函数的优点是，节省空间。

>>> for key, value in d.items():

...     print key, ':', value

...

Lisa : 85

Adam : 95

Bart : 59

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

print d.values()

# [85, 95, 59]

for v in d.values():

    print v

# 85

# 95

# 59

迭代values

                   

 

迭代values和key

 

 

 

Key和values

Values

values/itervalues

 

√itervalues节省空间

items/iteritems

√iterirems的函数节省空间

 

 

Set：

set是一系列元素的无序集合，没有重复，和dict的key类似，创建方法是将set传入list，list的元素将作为set的元素。 >>>s=set ( [ ‘a’, ’b’, ’c’ ] )

因为set中不能包含重复的元素，所以当传入元素的list包含重复元素时，set会自动删除重复元素。

Set的遍历：

使用for循环可以直接遍历set的元素。

Set的更新：

使用add和remove函数进行添加和删除。add函数可以直接添加，而remove函数

需要判断删除的元素是否在该set中，不在就报错。

列表生成：

L=[]

For x in range(1,11):

L.append(x*x)

 

需要生成list [1,2,3,4,5,6,7,8,9,10]，我们可以用range(1,11):，但是[1x1,2x2,3x3,……,10x10]，用range的方法表示就有点麻烦。循环太繁琐，而列表生成可以用一条语句代替循环。

>>>[x*xfor x in range(1,11)]

这是python特有的列表生成式，可以直接生成相应的列表。

 

Python复杂表达式：

在生成列表的时候，使用一些复杂的表达式，可以在HTML的语言环境下打印出表格。

 

tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]      列表生成式

print '<table boder=”1”>'

print '<tr><th>Name</th><th>Score</th><tr>'

print '\n'.join(tds)

print '</table>'

dict可以通过复杂的列表生成式将他转换成一个HTML表格。

将打印出的结果保存为HTML文件，就可以在浏览器中查看。

 

<tr>：tablerow的缩写，意思为表格行，一行以<tr>开头以</tr>结尾。

<table border="1">

<tr><th>Name</th><th>Score</th><tr>

<tr><td>Lisa</td><td>85</td></tr>

<tr><td>Adam</td><td>95</td></tr>

<tr><td>Bart</td><td>59</td></tr>

</table>

<td>：表格数据，格式：<td>数据类型</td>，可以在第一个<td>中加入数据的形式，颜色等，例如<td style=”color:red”>表示该数据类型显示时字体是红色。

Join()函数：字符串的join()可以把一个list拼接成一个字符串，’\n’.join(tds)，表示将换行符拼接到tds里。

 

 

列表生成条件过滤：

依然是生成列表的语句，在语句后加上if的条件判断语句，就能够实现选择。

def toUppers(L):

return [x.upper() for x in L if isinstance(x,str)]

 

print toUppers(['Hello', 'world', 101])

函数toUpper()是实现将一个list中的所有字符串转换为大写然后返回。

Upper()函数可以返回大写字母。Isinstance()函数可以判断是否为字符串。

>>> [m + n for m in 'ABC' for n in '123']

['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

多层表达式：

和C语言一样For循环可以嵌套，在列表生成中多层for循环也可以用来生成列表。

翻译成循环代码就是for循环下在嵌入一个for循环。