变量和类型
常见字符串处理
条件判断
循环控制
函数
对于python所有对象都是继承自object的类 容器:
整数 print(type(1234))
浮点数 print(type(123.))
字符串 print(type(123.))
布尔值 字典
空值
函数
def func(a, b, c):
print(a, b, c)
print(type(func))
a = func
print(type(a))
模块
import string
print(type(string))
类
class MyClass(object):
pass
print(type(MyClass))
my_class = MyClass()
print(type(my_class))
对于自己定义的类,它是属于type类型,(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是一个空指针,空字符串的话还是给它分配了一个对象,
在内存中还是有一个对象的,但是空字符串和False是等价的
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)
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')
{'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
作业:
打印100000以内的所有素数
自己实现一个函数支持可变参数
_
函数调用
函数名(参数名)
模块名.函数名(参数名)
带参数名调用
什么是递归?_
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))
手机扫一扫
移动阅读更方便
你可能感兴趣的文章