大纲
变量和类型
常见字符串处理
条件判断
循环控制
函数
变量和类型
基本变量类型
对于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(' ') s_2 = s.splitlines()#按行分割 print(s_1) print(s_2)
print(''.join(s_1))
print('-'.join(s_1))
print('
'.join(s_1))
类型转换：int, float转换
#数字转换成字符串 print(str(5)) print(str(5.)) print(str(5.1234)) print(str(-5.123)) #字符串到数字 print(int('1234')) print(float('1234.45')) print(int('123.45'))
print(int('123.45'))要传递正确的格式，如果格式错误，系统不会自动认为你是一个浮点数要转换成整数
#几进制的转换 print(int('110111', 2))#2进制转换成10进制 print(int('ffff', 16))#16进制转换成10进制 print(int('7777', 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(' 34abcd'.isalnum()) #False print('1234'.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))