python课程学习第二课

基本变量与类型

• 整型
• 浮点数
• 字符串
• 布尔值
• 空值
• 函数
• 模块
• 类型*
• 自定义类型
  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')
#作业四