字符串处理和循环控制

# -*- coding: utf-8 -*-
import string

s = 'abc'
s[0] = 'x'   #string不支持元素操作

#去除空格
s = ' abcd efg'
print(s.strip())  #去掉所有空格，返回的是新的字符串，因为字符串不能修改
print(s.lstrip()) #去掉左边空格
print(s.rstrip()) #去掉右边空格
print(s)

#字符串的连接
s1 = 'abc'
s2 = 'def'
print(s1 + '\n' + s2)

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

#位置比较
s_1 = 'abcdef'
s_2 = 'abdeffxx'
print(s_1.index('bcd'))

#在python3中，cmp函数被移除 字符串比较，排在前面的字符串小，当顺序一样时，长度长的大。
print(s_1 == s_2)
print(s_1 < s_2)
print(s_1 > s_2)

#长度
print(len('abcdef'))

#字符串的分割和连接
s = 'abc,def,ghi'
splitted = s.split(',')
print(type(splitted))  #返回的是一个数组 list
print(splitted)

s= '''abc
def
ghi
efg'''
s_1 = s.split('\n')
s_2 = s.splitlines()
print(s_1)
print(s_2)

s = ['abc','def','ghi']  #指定字符连接序列中元素后生成的新字符串
print(''.join(s))
print('-'.join(s))
print('\n'.join(s))

#常用判断
s = 'abcdefg'
print(s.startswith('abc'))
print(s.endswith('efg'))
print('1234abcd'.isalnum())
print('\t1234abcd'.isalnum())
print('abcd'.isalpha())
print('1234'.isdigit())
print('    '.isspace())
print('fasf'.islower())
print('ASD'.isupper())
print('Hello world'.istitle())

#数字到字符串
print(str(5))
print(str(5.))
print(str(5.123))
print(str(-5.1))

#字符串到数字
print(int('123'))
print(float('1.1'))
print(int('fff',16))  #后面代表16进制

#字符串本身不可以修改，那只能复制到一个lis数组中去
s = 'abcdsef'
l = list(s)
print(l)


#for 循环
#for i in 迭代器 range(start,end,steps)
for i in range(0,20,2):
    print(i)

#while循环
s= 0
i =1
while i<=100:
    s += i
    i +=1
print(s)

#continue,pass,break用法
'''
pass

不做任何事情，只起到占位的作用，也就是说它是一个空操作

continue

当continue语句在循环结构中执行时，并不会退出循环结构，而是立即结束本次循环，重新开始下一轮循环，
也就是说，跳过循环体中在continue语句之后的所有语句，继续下一轮循环。

break

当break语句在循环结构中执行时，它会导致立即跳出循环结构，转而执行该结构后面的语句。

exit()

结束整个程序
'''
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  #返回的是一个元祖，元祖不可以修改

r = func_name(1,2)
print(r)

#函数默认参数
def func(x, y=500):
    return x + y
print(func(100,600))
print(func(100))
print(func(y = 100, x =100))

#可变参数 必须在最后 就是把星号之后的作为可变参数处理
def func(name, *numbers):
    print(type(numbers)) #name之后的所有数值（啥类型都行）用星号打包成一个元祖 只读数组

#字典
def my_print(*args):
    print(args)

my_print(1,2,3,4,'a','b')
def func(name, **kvs): #**means key/value
    print(name)
    print(type(kvs))
    print(kvs)
func('Tom', china = 'Bejing', UK = 'London') #把变量名和传入的参数变成字典

#命名关键字参数
def func(a,b,c,*,china,uk):  #*号后面的变量必须带名字就是用 = 
    print(china,uk)
func(1,2,3,china = 'BJ', uk = 'LD')

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 = 'london')

#斐波那契数列  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)

#汉罗塔问题
        
def hanoi(n,source,target, helper):
    pass
    if n ==1:
        print(source + '->' + target)
    else:
        hanoi(n-1,source,helper,target)
        print(source + '->' + target)
        hanoi(n-1,target,helper,target)
hanoi(4,'A','B','C')

 #函数可以作为参数
p = print
p(1,2,3)

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