Python新手引导第二篇

Python新手引导 第四篇

###阅读本文需要4.66分钟

之后的引导将以例子入手,作为一个程序员,我相信你从例子入手的话会更快的掌握一门语言。

  1. 条件判断、循环、dict和set
  2. 函数
  3. 列表生成式
    update order_pay_num set content = ‘支付一次,永久免费使用’

    第一、条件判断、循环、dict和set

1.1 条件判断

1
2
3
4
5
6
7
8
#coding:utf-8
age = input('input num:')
if age > 18:
print('age 大于 18')
elif age > 11 and age < 18:
print('age 大于11 并小于18')
else :
print('其他')

如下:

1
2
3
4
5
6
7
8
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>

其中input():
2.x 下 input读取的内容和输入的一样的。 但在3.x以上 读取的都是字符串,这一点大家要和raw_input()做区分

1.2 循环

1.2.1 for in

1
2
3
names = ['Mark','Alison']
for name in names:
print(name)
1
for <元素> in <集合>:

在这里给大家讲一下 range(),rangek可以生成对应参数的n个整数。如: range(100),就会生成0 到 100的整数。因此在遍历list的时候也可以这样:

1
2
3
names = ['Mark','Alison']
for index in range(len(names)):
print(names[index])

1.2.2 while

1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n -2
print(sum)

1.3 集合

1.3.1 dict

Python中内置的字典。在其他语言中是 map之类的 (key-value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> names = {'Mark':'18','Alison':'18'}
>>> names
{'Alison': '18', 'Mark': '18'}
>>> names['Mark']
'18'
>>> names['Jordan'] = '88'
>>> names
{'Jordan': '88', 'Alison': '18', 'Mark': '18'}
>>> names.get('Ali','-1') #get方法可指定默认值,若这个key不存在,返回默认值
'-1'
>>> names.pop('Jordan') #Pop出栈
'88'
>>> names
{'Alison': '18', 'Mark': '18'}

dict适用于需要高速查找的地方。

1.3.2 set

一组不包含value的 key集合,并且不能重复。入参是 list

1
2
3
4
5
6
7
8
9
>>> a = set([1,2,3])
>>> a
set([1, 2, 3])
>>> a.add(5)
>>> a
set([1, 2, 3, 5])
>>> a.remove(5)
>>> a
set([1, 2, 3])

切记关于key的都是不可变的。因为存储的时候,是通过计算key的hash来做的。

第二、函数

2.1 内置函数

1
2
3
4
5
6
7
8
9
10
11
12
>>> abs(1.2) # 求绝对值
1.2
>>> abs(-1)
1
>>> int('1') # 将str的转换为int
1
>>> str(1) # 将int转换为str
'1'
>>> bool(1) # 转换bool值
True
>>> bool('')
False

2.2 定义函数

Python中使用def定义函数,并可通过 return来返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> def myAbs(x):
... if x > 0:
... return x
... else:
... return -x
...
>>>
>>> myAbs(1)
1
>>> myAbs(-1)
1
>>> myAbs(-2)
2

其中 return表示函数执行的终止,并将结果返回。
需要注意的是 return None可直接用 return表示

2.2.1 空函数

1
2
def nop():
pass #可作为占位符,表示还没想好写什么

2.2.2 返回多个值

1
2
3
def fun():
return '1','2'
a,b = fun()

这个还是比较方便的。 不用我们再继续封装起来返回,唯一恶心的就是得约定好规则。

其实这返回不是两个值,而是一个tuple,这个得理解下

2.2.3 默认参数

1
2
def fun(a,b=2)
print a,b

其中b的默认值是2

1
2
3
def fun(L=[])
L.append('End')
return L

传一个list,并添加 End再返回。其中要注意的是,python会记住append的元素。意思就是:如果你多次调用 fun() ,会发现 之后的元素都是 End

因此这种传递List的方式如下:

1
2
3
4
5
def fun(L=None):
if L is None:
L = []
L.append('End')
return L

2.2.4 可变参数,使用 *

1
2
3
4
5
6
7
nums = [1,2,3]
def addNum(*n):
sum = 0
for num in n:
sum +=num
return sum
addNum(*nums)

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

2.2.5 关键字参数 **

表示允许传入0个或者任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict.

1
2
3
4
5
6
7
8
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:

1
2
3
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

或者

1
2
3
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

2.2.6 命名关键字参数

对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些,就需要在函数内部通过kw检查。

仍以person()函数为例,我们希望检查是否有city和job参数:

1
2
3
4
5
6
7
8
def person(name, age, **kw):
if 'city' in kw:
# 有city参数
pass
if 'job' in kw:
# 有job参数
pass
print('name:', name, 'age:', age, 'other:', kw)

但是调用者仍可以传入不受限制的关键字参数:

1
>>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收city和job作为关键字参数。这种方式定义的函数如下:

1
2
def person(name, age, *, city, job):
print(name, age, city, job)

和关键字参数*kw不同,命名关键字参数需要一个特殊分隔符,*后面的参数被视为命名关键字参数。

调用方式如下:

1
2
>>> person('Mark', 24, city='hangzhou', job='Engineer')
Mark 24 hangzhou Engineer

第三、列表生成式

List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式

举例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> [x*x for x in range(1,11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
>>>
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
>>>
>>>
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
... print(k, '=', v)
...
y = B
x = A
z = C

第四、生成器 generator

如名字,其就是一个生成我们所需数据的容器,而不像 列表生成式,计算出所有数据。因此节省了空间,也解决了时间

1
2
3
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

遍历: next(g)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> g = (x * x for x in range(10))
>>> for n in g:
... print(n)
...
0
1
4
9
16
25
36
49
64
81

yeild可中断当前操作,使函数成为 生成器 而不是普通函数

举例: 杨慧三角

1
2
3
4
5
6
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1
2
3
4
5
6
7
8
9
10
11
12
def yanghu(n):
L=[1]
while 1:
yeild L
L = [L[x] + L[x+1] for x in range(len(L) -1)]
L.insert(0,1)
L.append(1)
if len(L)>n:
break
for n in yanghu(10):
print n

小结

本篇用一些简单的例子来讲解了下基础知识。 多动手练练哦