strip去除空格

s = ' abcd efg  '
print(s.strip())    #去除所有空格
print(s.lstrip())   #去除左边空格
print(s.rstrip())   #去除右边空格
print(s)
abcd efg
abcd efg  
abcd efg
abcd efg  


大小写

s = 'abc defg'
print(s.upper())
print(s.upper().lower())
print(s.capitalize())  #首字母大写
ABC DEFG
abc defg
Abc defg


位置和比较

s_1 = 'abcdefg'
s_2 = 'abdefgh'
print(s_1.index('bcd'))
try:
    print(s_1.index('bce'))
except ValueError:
    print('ValueError: substring not found')

print(s_1 == s_1)   # cmp函数被Python3移除了
print(s_1 > s_2)
print(s_2 > s_1)

1
ValueError: substring not found
True
False
True

s = ''
if not s:
    print('true')
else:
    print('flase') #空字符串和flase是等价的


true


分隔和连接

s = 'abc,def,ghi'
print(s.split(','))
s = '123\n456\n789'
numbers = s.split('\n')   #按行分隔
numbers = s.splitlines()  #按行分隔
print(numbers)
print('-'.join(numbers))  

['abc', 'def', 'ghi']
['123', '456', '789']
123-456-789


常用判断

s = 'abcdefg'
print(s.startswith('abc'))    #判断是否以某个字符串为开头
print(s.endswith('efg'))      #判断是否以某个字符串为结尾
print('abcd1234'.isalnum())   #string中至少有一个字符，而且全是字母或者数字或者是字母和数字混合返回True，其他情况返回False
print('\tabcd1234'.isalnum())
print('abcd'.isalpha())       #string中至少有一个字符，而且全为字母，返回True，其他情况返回False
print('12345'.isdigit())      #输入字符串是否只由数字组成
print('  '.isspace())
print('acb125'.islower())
print('A1B2C'.isupper())
print('Hello world!'.istitle())  #检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写


True
True
True
False
True
True
True
True
True
False


函数

函数定义与默认参数

def func(x, y = 500):
    print(x, y)


func(150)
func(100, 200)
func(y = 300, x = 100)

150 500
100 200
100 300
可变参数

def func(name, *numbers):  #加一个星号，就表示告诉python，在处理后面所有参数的时候，把这些参数放到一个数组里面
    print(name)
    print(numbers)
    print(type(numbers))


func('Tom', 1, 2, 3, 4)

Tom
(1, 2, 3, 4)
<class 'tuple'>        
#tuple - 元组，等价于只读数组，就是后面所有的参数都会作为一个数组
关键字参数

def func(name, **kvs):  # **意思是把它装到 key/value 字典里，转化成字典了
    print(name)
    print(kvs)
    print(type(kvs))


func('Jack', china = 'Beijing', uk = 'London')
Jack
{'china': 'Beijing', 'uk': 'London'}
<class 'dict'>
命名关键字参数

def func(a,b,c,*, china, uk): # *用于和普通参数做分割，*args一样效果
    print(china, uk)


func(1,2,3,china = 'Beijing', uk = 'London')  # *后面传递的参数必须传入参数名

Beijing London
复杂情况

def func(a, b, c = 0, *args, **kvs):
    print(a, b, c, args, kvs)


func(1, 2)
func(1, 2, 3)
func(1, 2, 3, 'a', 'b')
func(1, 2, 3, 'a', 'b', china = 'Beijing', uk = 'London')
func(1, 2, 3, *('a', 'b'), **{'china':'Beijing', 'uk':'London'})  #提高代码的可读性

1 2 0 () {}
1 2 3 () {}
1 2 3 ('a', 'b') {}
1 2 3 ('a', 'b') {'china': 'Beijing', 'uk': 'London'}
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 sum(x,y,p = None):
    s = x + y
    if p:
        p(s)
    return


sum(100,200)
sum(100,200,print)

300
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
1


递归

把一个大问题分解成同样结构的小问题， 然后利用小问题的解得出大问题的解

def my_sum(i):
    if i < 0:
        raise ValueError
    elif i <=1:
        return i
    else:
        return i + my_sum(i - 1)  # my_sum(i - 1)是它更小范围内的解，利用这个子问题的解得出当前的解

print(my_sum(1))
print(my_sum(2))
print(my_sum(3))
print(my_sum(10))
print(my_sum(100))

1
3
6
55
5050
# 递归的经典例子！
# 斐波那契数列 f(n) = f(n - 1) + f(n -2)
def fib(n):
    if n < 1:
        raise ValueError
    elif (n == 1) or (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))



---------------------
【转载】
作者：天行_
原文：https://blog.csdn.net/lens___/article/details/84190533