【JulyEdu-Python基础】第 2 课：关键字和循环控制

大纲

变量和类型
常见字符串处理
条件判断
循环控制
函数

变量和类型

基本变量类型

对于python所有对象都是继承自object的类　　　　　　容器：

整数　　print(type(1234))　　　<class 'int'>　　　　列表　　　<class 'list'>　　print(type([1, 2, 3, 'a', 'b']))
浮点数　print(type(123.))　　　<class 'float'>　　　元组　　　<class 'tuple'> 　print(type((1, 'abc')))
字符串　print(type(123.))　　　<class 'str'>　　　　集合　　　<class 'set'> 　　print(type(set(['a', 'b', 3])))
布尔值　　　　　　　　　　　　　　　　　　　　　　　字典　　　<class 'dict'>　　print(type({'a': 1, 'b': 2}))
空值
函数　　<class 'function'>

def func(a, b, c):
    print(a, b, c)

print(type(func))
a = func
print(type(a))

模块　　<class 'module'>

import string
print(type(string))

类　　　　<class 'type'>　　　　<class '__main__.MyClass'>

class MyClass(object):
    pass
print(type(MyClass))
my_class = MyClass()
print(type(my_class))

对于自己定义的类，它是属于ｔｙｐｅ类型，（type也是一个类型，用来描述类型的类型（元编程）

　　所有的类的背后也是有一个类来描述这些类的）

实例化了一个类之后，这个实例就是所对应的类型

在python里所有的对象都是类，甚至类本身也是一个类

类型*
自定义类型

变量定义

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

x = 100

在堆上分配了一个int，4个字节，在python64位可能就8个字节，这8个字节里写了一个100，

x实际上就是指向存放100的这个内存地址。

所有的变量实际上是一个内存地址，指向堆上的一个内存地址

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。（弱类型）

变量赋值

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。（重要！！！）
等号（=）用来给变量赋值，等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

try:
    print(x)
except NameError:
print('NameError: "x" is not defined')

常见字符串处理

import string
s = 'abc'
s[0] = 'x'

TypeError: 'str' object does not support item assignment

字符串可以当作一个数组访问,但是不能被修改，类型错误，不支持元素的赋值操作

去除空格及特殊符号：strip, lstrip, rstrip

import string
#去除空格
s = '   abcd  efg   '
print(s.strip())

print(s.ltrip())

print(s.rtrip())
print(s)#本身并没有被修改

在调用strip之后会返回一个新的字符串，因为字符串本身不可以被修改，

所以它调用了这种操作，修改字符串操作之后，一定是返回一个新的字符串

复制字符串：str1 = str2
连接字符串
str2 += str1
new_str = str2 + str1
查找字符串：pos = str1.index(str2)
比较字符串：cmp(str1, str2)

import string

#位置比较
s_1 = 'abcdefg'
s_2 = 'abdeffxx'
print(s_1.index('bcd'))
try:
    print(s_2.index('bcd'))
except ValueError:
    pass

在python3里面cmp函数被移除了，可以直接用> < == 比较字符串

print(s_1 == s_2)　　False
print(s_1 < s_2)　　 True
print(s_1 > s_2)　　 False

字符串长度：len(str)

s = ''
if s is None:
    print('None')

空字符串和None是两回事，None是一个空指针，空字符串的话还是给它分配了一个对象，

在内存中还是有一个对象的，但是空字符串和Ｆａｌｓｅ是等价的

s = ''
if s is None:
    print('None')
if not s:
    print('Empty')

大小写转换
u_str = str.upper()
l_str = str.lower()
首字母大写：str.capitalize(); string.capword(str)

import string

#大小写
s = "abc def"
print(s.upper())
print(s.upper().lower())
print(s.capitalize())

分割与合并字符串：split, splitlines, join

#分割和连接
s='abc,def,ghi'
splitted = s.split(',')
print(type(splitted))
print(splitted)

s = """abc
def
ghi
efg"""
s_1 = s.split('\n')
s_2 = s.splitlines()#按行分割
print(s_1)
print(s_2)

print(''.join(s_1))
print('-'.join(s_1))
print('\n'.join(s_1))

类型转换：int, float转换

#数字转换成字符串
print(str(5))
print(str(5.))
print(str(5.1234))
print(str(-5.123))
#字符串到数字
print(int(''))
print(float('1234.45'))
print(int('123.45'))

print(int('123.45'))要传递正确的格式，如果格式错误，系统不会自动认为你是一个浮点数要转换成整数

#几进制的转换
print(int('', 2))#2进制转换成10进制
print(int('ffff', 16))#16进制转换成10进制
print(int('', 8))

#由于字符串本身不可以被修改，
#把字符串赋值到数组里面去
s = "abcdefg"
l = list(s)
print(l)

作业：

字符串按单词反转，必须保留所有空格('I love China!  ')

格式化字符串

字符串测试
str.startswith(prefix)
str.endswith(suffix)
str.isalnum() # 是否全是字母和数字，并至少有一个字符。
str.isalpha() # 是否全是字母，并至少有一个字符。
str.isdigit() # 是否全是数字，并至少有一个字符。
str.isspace() # 是否全是空白字符，并至少有一个字符。
str.islower() # 字母是否全是小写
str.isupper() # 字母是否全是大写
str.istitle() # 首字母是否大写

#常用判断
s = "abcdefg"
print(s.startswith('abc'))
print(s.endswith('efg'))
print('1234abcd'.isalnum())
print('\t34abcd'.isalnum())　　#False
print(''.isdigit())
print('abcd'.isalpha())
print('   '.isspace())
print('abcd12345'.islower())
print('ABCD1234'.isupper())
print('Hello world'.istitle())　　#False
#istitle()如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.

条件判断

python 中没有switch函数的只能有if elif else来完成

真值判断
if x == True:
if x:
if not x:

#if判断
a = 100
b = 200
c = 300
if c == a:
    print(a)
elif c == b:
    print(c)
else:
    print(b)

空值判断
if x is None:
if not x:

#None的判断
x = None
if x is None:
    print('None')
else:
    print('not None')

比较
if a == b:
if a > b:
...

循环控制

for循环
for i in range(begin, end, steps): <=> for (i = begin; i < end; i += steps)
while循环
while 条件判断:
循环嵌套
循环控制
break
continue
pass

# for 循环
#for (i = start; i < end; i += step)

#for i in 容器（可迭代的）

for i in range(0,30, 5):
    print (i) 

# while 循环

s = 0
i = 1
while i <= 100:
    s += i
    i += 1

print (s)

for i in range(0,100):
    if i < 10:
        pass
    elif i < 30:
        continue
    elif i < 35:
        print(i)
    else:
        break

函数

def func_name(arg_1, arg_2):
    print (arg_1, arg_2)
    return arg_1, arg_2#返回多个值，实际返回的是一个元组，只读的list

r = func_name(1, 2)
print(type(r))
print(r)
print(r[0], r[1])

函数定义格式

　　默认参数

def func(x, y = 500):
    return x + y

print(func(100, 600))　　
print(func(100))

　　

def func(x, y = 500):
    print('x=', x)
    print('y=', y)
    return x + y

print(func(100))
print(func(y = 300, x = 200))
print(func(x = 400))

在函数调用的时候，把参数的名字给写出来，并给它指定一个值，

不用严格按照参数次序，代码的可读性提高

def func(p):
    print('x=', p['x'])
    print('y=', p['y'])

print(func({'x':100, 'y':200}))#用字典实现类似的功能

　　可变参数：*args，自动组装成tuple

#可变参数

#main(int argc, char ** argv)
#printf

def func(name, *numbers):
    print(type(numbers))

func('Tom', 1, 2, 3, 4, 5)

从name之后，后面所有的参数，它会打包成一个元组，一个只读的数组

#tuple - 元组　　<=>   只读数组，后面的所有参数都会作为一个数组

*numbers前面加一个*号，告诉python处理后面所有参数时，放到一个数组里面去

def func(name, *numbers):
    print(numbers)
    print(numbers[0])　　#1
    print(numbers[3])　　#4
    return 'Done'
func('Tom', 1, 2, 3, 4, 5, 'abc', 'def')

容器是不用考虑类型一致性，计算的时候才会有要求

可变参数是没有名字的，只能有数组索引，python提供另一种方法，

传入字典　　使用　**

def my_print(*args):
    print(args)

my_print(1, 2, 3, 4, 'a', 'b', 'c')

def func(name, **kvs): # ** means key/values
    print(name)
    print(type(kvs))
    print(kvs)
func('Tom', china = 'Beijing', uk = 'London')

<class 'dict'>
{'china': 'Beijing', 'uk': 'London'}

　　关键字参数：*args，自动组装成dict
　　命名关键字参数

def func(a, b, c, *, china, uk):
    print(china, uk)
func(1, 2, 3, china = 'Beijing', uk = 'London')

* 号后面的变量，意味着在传递参数的时候，一定要把它的名字带上

def func(a, b, c = 0, *args, ** kvs):
    print(a, b, c)
    print(args)
    print(kvs)

func(1, 2)
func(1, 2, 3)
func(1, 2, 3, 'a','b', 'c')
func(1, 2, 3, 'a', 'b', china = 'BJ', uk = 'LD')

#为了代码可读性高一些，*代表传递给args
func(1, 2, 3, *('a', 'b'), **{'china' : 'BeiJing', 'uk' : 'London'})

1 2 0
()
{}
1 2 3
()
{}
1 2 3
('a', 'b', 'c')
{}
1 2 3
('a', 'b')
{'china': 'BJ', 'uk': 'LD'}
1 2 3
('a', 'b')
{'china': 'BeiJing', 'uk': 'London'}

def my_print(*args):
    print(*args)

my_print('x=', 100, ';y=', 200)

x= 100 ;y= 200

---

作业：

打印１０００００以内的所有素数

自己实现一个函数支持可变参数

---

函数调用
　　函数名(参数名)
　　模块名.函数名(参数名)
　　带参数名调用
什么是递归？

def my_sum(i):
    if i < 0:
        raise ValueError
    elif i <= 1:
        return i
    else:
        return i + my_sum(i-1)

print(my_sum(1))
print(my_sum(2))
print(my_sum(3))
print(my_sum(4))
print(my_sum(100))

1
3
6
10
5050

斐波那契数

#f(n) = f(n-1) + f(n-2)

def fib(n):
    if n < 1:
        raise ValueError
    elif n <= 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(6))

1
1
2
3
5
8

def hanoi(n, source, target, helper):
    if n == 1:
        print(source + '->' + target)
    else:
        hanoi(n-1, source, helper, target)
        print(source + '->' + target)
        hanoi(n-1, helper, target, source)

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

A->C
A->B
C->B
A->C
B->A
B->C
A->C
A->B
C->B
C->A
B->A
C->B
A->C
A->B
C->B

# 在python里函数是可以作为参数的

p = print
p(1,2,3)

def sum(x, y, pf = None):
    s = x + y
    if pf:
        pf(s)
    return s

sum(100, 200)
sum(100, 200, print)

def cmp(x, y, cp = None):
    if not cp:
        if x > y:
            return 1
        elif x < y:
            return -1
        else:
            return 0
    else:
        return cp(x, y)

def my_cp(x, y):
    if x < y:
        return 1
    elif x == y:
        return 0
    else:
        return -1

print(cmp(100,200))
print(cmp(100, 200, my_cp))

1 2 3
300
-1
1

---

作业：

　　字符串按单词反转（必须保留所有空格）：'I love China!   ' 转化为 '   China! love I'

　　打印100000以内的所有素数

　　自己实现一个函数支持可变参数

　　自己实现函数解决hanoi塔问题

　　实现一个sort函数，通过参数指定比较函数用来实现按不同顺序进行排序

---

在python里面，因为函数本身也是一个对象，所以它可以像普通变量一样，被作为参数传递来传递去

def do_sum(data, method):
    return method(data)

print(do_sum([1, 2, 3, 4], sum))