基本变量与类型
- 整型
- 浮点数
- 字符串
- 布尔值
- 空值
- 函数
- 模块
- 类型*
- 自定义类型
python中都是类int/integer无区别,都继承自object
print(type(100))
print(type(123.45))
print(type(123.))
print(type('abc'))
print(type([1,2,3,'a','b','c']))
print(type(set([1,'abc'])))
print(type((1,2,3,'abc')))
print(type({'a':1,'b':2}))
#函数
def fun(a,b,c):
print(a)
print(type(fun))
a=fun
print(type(a))
#模块
import string
print(type(string))
#class
class MyClass(object):
pass
a=MyClass()
print(type(MyClass))
print(type(a))
#输出
<type 'int'>
<type 'float'>
<type 'float'>
<type 'str'>
<type 'list'>
<type 'set'>
<type 'tuple'>
<type 'dict'>
<type 'function'>
<type 'function'>
<type 'module'>
<type 'type'>
<class '__main__.MyClass'>
变量和类型
- 变量定义
- 变量存储在内存中的值,这就意味着在创建变量时会在内存中开辟一个空间
- 基于变量的数据类型,解释器会分配指定的内存,并解决什么数据可以被存储在内存中
- 变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。(弱类型)
- 变量赋值
- 每个变量在使用前必须赋值,变量赋值以后该变量才会被创建。(重要)
- 等号(=)用来个变量赋值,等号(=)左边是一个变量名,等号(=)右边是一个存储在变量中的值
try:
print(x)#变量使用前必须赋值
except NameError:
print('NameError "x" not define')
字符串的处理
#字符串支持值得读取,但不支持修改
import string
s='abc'
s[0]='e'
TypeError: 'str' object does not support item assignment
- 去掉空格及特殊字符:strip(),lstrip(),rstrip()
- 复制字符串:str1=str2
- 连接字符串
- str2+=str1
- new_str=str1+str2
- 查找字符串:pos=str1.index(str2)
- 比较字符串:cmp(str1,str2)
- 字符串长度:len(str1)
- 大小写转换
- u_str=str.upper()
- l_str=str.lower()
- 首字母大写:str.capitalize(),string.capword(str)
- 分割与合并字符串:split,splitlines,join
- 类型转换:int,float转换
- 格式化字符串
import string
s=' abc defg '
#去除空格
print(s.strip())
print(s.lstrip())
print(s.rstrip())
print(s)
#字符串的连接
print('abc'+'\n'+'def')
#大小写转换
s='abc def'
print(s.upper())
print(s.upper().lower())
print(s.capitalize())
#位置比较
try:
s_1='abcdefg'
s_2='abdeffxx'
print(s_1.index('bcd'))
print(s_2.index('bcd'))
except ValueError:
print('ValueError')
#在Python3中cmp函数被移除,直接用>,<,==比较
print(s_1==s_2)
print(s_1>s_2)
print(s_1<s_2)
#长度
print(len('abc'))
s=''
if not s:
print('empty')
if s is False:
print('is empty')
#分割与连接
s='abc,def,ghi'
sp=s.split(',')
print(type(sp))
print(sp)
s='''abc
def
hmj'''
s1=s.split('\n')
s2=s.splitlines()
print(s1)
print(s2)
s=['abc','def','hij']
print(''.join(s))
print('-'.join(s))
print('\n'.join(s))
#常用判断
s='abcdefg'
print(s.startswith('abc'))
print(s.endswith('efg'))
print('1234abc'.isalnum())
print('\t1234abc'.isalnum())#是否全是数字和字母
print('abc'.isalpha())#是否全是字母
print('1234'.isdigit())#是否全是数字
print(' '.isspace())#是否是空格
print('1234abc'.islower())#是否小写
print('1234ABC'.isupper())#是否是大写
print('Hello World'.istitle())#判断首字母是否是大写
#数字转换为字符串
print(type(str(1)))
print(type(str(1.2)))
print(type(str(1.)))
print(type(str(11)))
#字符串到数字
print(int('123'))
print(float('123.1'))
print(int('11111',2))
print(int('ffff',16))
print(int('7777',8))
try:
print(int('12.1'))#不会将float型自动转换为int
except ValueError:
print('ValueError')
abc defg
abc defg
abc defg
abc defg
abc
def
ABC DEF
abc def
Abc def
1
ValueError
False
False
True
3
empty
<type 'list'>
['abc', 'def', 'ghi']
['abc', 'def', 'hmj']
['abc', 'def', 'hmj']
abcdefhij
abc-def-hij
abc
def
hij
True
True
True
False
True
True
True
True
True
True
<type 'str'>
<type 'str'>
<type 'str'>
<type 'str'>
123
123.1
31
65535
4095
ValueError
条件判断
- 真值判断
- if x==True:
- if x:
- if not x:
- 空值判断
- if x is none:
- if not x:
- 比较
- if a == b:
- if a>b:
#if 判断
a=100
b=200
c=300
if c==a:
print(a)
elif c==b:
print(b)
else:
print(c)
#none的判断
x=None
if x is None:
print(x)
if not x:
print('not none')
if x is not None:
print('not none')
300
None
not none
循环语句
- for: for i in 可迭代的元素
- while
range(start(开始元素),end(结束元素),step(步长))
#for循环
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
0
5
10
15
20
25
5050
30
31
32
33
34
函数
- 函数定义格式
- 默认参数
- 可变参数:”args,自动组装成元组”
- 关键字参数 :”args,自动组装成dict”
- 函数调用
- 函数名(参数名)
- 模块名.函数名(参数名)
- 带参数名调用
- 什么是递归
#函数
def func(arg_1,arg_2):
print(arg_1,arg_2)
return arg_1,arg_2#发回多个时返回元组,只读
r=func(1,2)
print(type(r))
print(r[0],r[1])
def fun(a,b,c,*,china,uk): #*后的参量必须带名字
print(china,uk)
fun(1,2,3,china='beijing',uk='London')
#函数
def func(x,y=500):
print('x=',x)
print('y=',y)
return x+y
print(func(100,200))
print(func(y=100,x=100))#通过前面带上参数名,可以改变传参数的顺序,提高代码的可读性
def fun(p):#用字典实现上述功能
print('x=',p['x'])
print('y=',p['y'])
print(fun({'x':100,'y':200}))
#可变参数,在名字上做手脚
def func(name,*numbers):#告诉Python,将name之后当做一个只读数组
print(type(numbers))
print(numbers)
print(numbers[0])
print(numbers[3])
#tuple -元组 <=>只读数组
func('Tom',1,2,3,4,'abc','def')
def my_print(*args):
print(args)
my_print(1,2,3,'a','b')
def func(name,**numbers):#** means key/value
print(type(numbers))
print(numbers)
func('Tom',china='beijing',uk='London')
def func(a,b,c=0,*args,**kvs):
print(a,b,c)
print(args)
print(kvs)
func(1,2,3)
func(1,2)
func(1,2,3,'a','b','c',ch='beijing',uk='London')
func(1,2,3,*('a','b','c'),**{'ch':'beijing','uk':'London'})#为了提高可读性
def func(*args):
print(args)
func('x=',100,';y=',200)
#递归求和
def my_sum(x):
if x<0:
raise ValueError#raise相当于throw,抛出异常
elif x<=1:
return x
else :
return x+my_sum(x-1)
print(my_sum(1))
print(my_sum(2))
print(my_sum(100))
#菲波拉契数 f(n)=f(n-1)+f(n-2)
def func(x):
if x<1:
raise ValueError
elif x <=2:
return 1
else:
return func(x-1)+func(x-2)
print(func(1))
print(func(3))
print(func(4))
#汉诺塔问题
def hanoi(n,A,B,C):
if n==1:
print(A+'->'+B)
else:
hanoi(n-1,A,C,B)
print(A+'->'+B)
hanoi(n-1,C,B,A)
hanoi(4,'A','B','C')
def cmp(a,b,p=None):
if not p:
if a>b:
return 1
elif a<b:
return -1
else:
return 0
else:
return p(a,b)
def my_cmp(a,b):
if a>b:
return -1
elif a==b:
return 0
else:
return 1
print(cmp(1,2))
print(cmp(1,2,my_cmp))
def do_sum(data,method):
return method(data)
print(do_sum([1,2,3,4],sum))
#函数可以做参数
p=print
p(1,2,3)
def sum(a,b,p=None):
s=a+b
if p:
p(s)
return s
sum(100,200)
sum(100,200,print)
(1, 2)
<type 'tuple'>
(1, 2)
('x=', 100)
('y=', 200)
300
('x=', 100)
('y=', 100)
200
('x=', 100)
('y=', 200)
None
<type 'tuple'>
(1, 2, 3, 4, 'abc', 'def')
1
4
(1, 2, 3, 'a', 'b')
<type 'dict'>
{'china': 'beijing', 'uk': 'London'}
(1, 2, 3)
()
{}
(1, 2, 0)
()
{}
(1, 2, 3)
('a', 'b', 'c')
{'ch': 'beijing', 'uk': 'London'}
(1, 2, 3)
('a', 'b', 'c')
{'ch': 'beijing', 'uk': 'London'}
('x=', 100, ';y=', 200)
1
3
5050
1
2
3
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
-1
1
10
作业
- 字符串安单词反转(必须保留所有空格)。‘I love china!’转化为’china! love I’
- 打印100000以内的素数
- 自己实现一个函数支持可变参数
- 自己编写函数实现hanoi塔
- 实现一个sort函数。通过参数指定比较函数用来实现按不同顺序进行排序
#作业一
s='I love china!'
sp=s.split(' ')
le=len(s)
res=''
i=0
j=0
flag=False
while i<le:
if s[i]==' ':
if flag==False:
res=sp[j]+res
j+=1
res=' '+res
flag=True
else:
flag=False
i+=1
res=sp[j]+res
res
#作业二
import math
def sushu(x):
i=2
flag=False
while x>1:
while i<=int(math.sqrt(x)):
if x%i==0:
flag=True
break
i+=1
if flag==False:
print(x)
else:
flag=False
x-=1
i=2
a=sushu(10000)
#作业三
def hanoi(n,A,B,C):
if n==1:
print(A+"->"+B)
return
else:
hanoi(n-1,A,C,B)
print(A+'->'+C)
hanoi(n-1,C,B,A)
hanoi(4,'A','B','C')
#作业四