python实用语法

1.判断字符串是否包含定义字符串

1.if str1 in str2:

#包含的话，True

2.if str1.find(str2)>=0:

#包含的话，返回第一次出现的位置，没有的话为负数

2.raw_input()和input()区别

#raw_input()默认把所有输入当作字符串处理

#input() 输入进来什么类型就是什么类型

#也就是说，数字类型直接输入它就是数字类型，你不能把它当作字符串操作处理，不然报错，你可以加str()强转

#如果输入字符串你要带"",不然会报错 "xx is not defined"

3.文件写操作

注意模式的更换，如果文件存在，不想覆盖原内容的话，选择a+模式即可。

f=file("hello.txt","w")

li=["hello world\n","hello china\n"]

f.writelines(li)

for key in li:

f.write(key)

f.close()

#或者是通过with open：

dest = "hello1.txt"

res = "world"

with open(dest,'w') as f:

f.write(res)

f.close()

4.文件读操作

​牵扯到编码的话，这里可以加mode ，encoding = 'xx'，python2.7需要使用io.open(open会报错)，python3使用open不会报错

#比如文件现在有两行，进行读操作：

'''

hello，world

hello, China

'''

import io

file_name = "hello.txt"

with io.open(file_name, 'r+', encoding = 'utf-8') as f:

read_data = f.read()

print read_data

#readline会记住上一个readline函数读取的位置，接着读取下一行,(size)为读取当前行长度

#readlines方法则是读取所有行，返回的是所有行组成的列表。

#read()直接读取

with open(file_name) as f:

# print(f.readlines())

# print(f.readline())

# print(f.readline())

# print(f.readline(3))

read_data = f.read()

print read_data

f.close()

5.字符串分割

#1.split()函数

#str.split('分割符'),通过该分割操作后，会返回一个列表。

str_test = "hello,world"

print str_test.split(',')

#2.splitlines()函数

#object.splitlines(),按行分割，通过该分割操作后，会返回一个列表。strip()去除前后空格

str_test = '''

hello

world

'''

res = (str_test.strip()).splitlines()

print res

#3.正则表达式分割

#re.split('分割符1|分割符2'，objects) --> 不同的分割符用'|'进行间隔(分割符需要进行'\'的转义操作)，然后objects为需要分割的字符串对象。

import re

test = 'hello,www@or#ld'

print re.split('@|\#',test)

#4.使用replace 替换成换行符

test = 'hello,www@or#ld'

print test.replace('@',"\n")

6.字符串遍历

#1. for in

test = 'hello,world'

for char in test:

print char

#2.for in range() or xrange()

for index in range(len(test)):

print test[index]

#3.enumerate()

for index,char in enumerate(test):

print index,test[index],char

#4.iter()

for char in iter(test):

print char

7.字符串拼接

#1. 使用'+'连接

test = "hell"

test1 = "o"

print test+test1

#2.使用.join(iterable) 拼接

list_str = [test,test1]

res = ''

print res.join(list_str)

#3.format 拼接

#eg(1){}占位符

str_test = 'hello,world {}{}'.format("你好","世界")

print str_test

#eg(2){[index]} 按索引位置填充 .format([0]=value1, [1]= value1},)

str_test1 = 'hello,world {0}{1}'.format("你好","世界")

str_test2 = 'hello,world {1}{0}'.format("你好","世界")

print str_test1

print str_test2

# eg(3) {[keyword]}

str_test3 = 'hello,world {name}{value}'.format(name = "你好",value ="世界")

print str_test3

8.初始化一个固定长度的数组

#方法1

N = 5

listOfLists = [[] for i in range(N)]

print listOfLists

#方法2

lst = [None] * 5

print lst

9.列表去除重复元素

#方法1

#通过set函数去重

list1=[11,22,11,22,33,44,55,55,66]

print(list1)

print(list(set(list1)))

#方法2

list1=[11,22,11,22,33,44,55,33,66]

list2=[]

for i in list1:

if i not in list2:

list2.append(i)

print(list1)

print(list2)

10.深拷贝和浅拷贝的区别

#浅拷贝:就是在内存中将第一层额外开辟空间进行存放。

import copy

n1 = {"k1": "abc", "k2": 123, "k3": ["abc", 123]}

print(id(n1)) #4514185296

n2 = copy.copy(n1)

print(id(n2)) #4514186976可以看n2的内存地址已经和n1不同了

print(id(n1['k3'])) #4514126448

print(id(n2['k3'])) #4514126448 字典里的列表还是指向同一个列表

#深拷贝就是在内存中将数据重新创建一份，不仅仅是第一层，第二层、第三层...都会重新创建

n1 = {"k1": "abc", "k2": 123, "k3": ["abc", 123]}

print(id(n1)) #4390219856

n3 = copy.deepcopy(n1)

print(id(n3)) #4390222096

print(id(n1['k3'])) #4390161008

print(id(n3['k3'])) #4390160936 #可以看到第二层的列表也拷贝了一份，内存地址已经完全不一样

11.关于可变参数和关键字参数的传递

#1.位置参数

def Foo1(arg1, arg2):

print(arg1, arg2)

Foo1('abc', 123)

#输出结果 abc 123

#2.默认参数

#我们可以给某个参数指定一个默认值，当调用时，如果没有指定那个参数，那个参数就等于默认值

def Foo2(arg1, arg2 = 123):

print(arg1, arg2)

Foo2('abc')

Foo2('abc', 345)

#3.可变参数

#可变参数就是传入的参数个数是可变的，也可以是0个，例如

def Foo3(*args):

print(args)

Foo3(1, 2, 'abc')

#4.关键字参数

#可变参数在调用过程中会组装成元组，元组只能通过索引进行调用，有时不是很方便，故Python可以通过关键字索引将传入的参数组装成字典

def Foo4(**kwargs):

print(kwargs, type(kwargs))

Foo4(k1 = 'abc', k2 = 123)

#执行结果 {'k2': 123, 'k1': 'abc'}

#关键字参数允许传入0个或任意个参数名的参数，0个的话就是一个空字典

#5.参数组合

#在Python中定义函数，可以用必选参数(位置参数)、默认参数、可变参数、关键字参数这几种参数进行组合使用，但是顺序必须是，必选参数、默认参数、可变参数、关键字参数。

def Foo5(arg1, arg2='abc', *args, **kwargs):

print('arg1:', arg1)

print('arg2:', arg2)

print('args', args)

print('kwargs', kwargs)

Foo5(123, 'abc', 456, 'def', k1=123, k2='abc')

'''

执行结果

arg1: 123

arg2: abc

args (456, 'def')

kwargs {'k1': 123, 'k2': 'abc'}

'''

#6.关于可变参数和关键字参数的传递小技巧

#可变参数和关键字参数分别将传递的参数组装成元组和字典，那么同样可以直接将元组、列表和字典直接传递给函数作为参数，传递的时候列表和元组要在变量前面加一个*，字典要在前面加两个*，否则函数还是会把它们当成一个普通的参数传递进行处理

def Foo6(*args, **kwargs):

print(args)

print(kwargs)

li = [1, 2, 3]

dic = {'k':1, 'k2':2}

Foo6(li, dic)

Foo6(*li, **dic)

'''

执行结果

([1, 2, 3], {'k': 1, 'k2': 2})

{} #可以看到两个参数都被可变参数接收了，关键字参数啥也没有

(1, 2, 3)

{'k': 1, 'k2': 2}

'''

12.lambda匿名函数

匿名函数就是功能非常简单只需要一行代码就可以实现的，例如，求圆形面积

f = lambda r: 3.14 * r * r

print(f(4)) # 输出 50.24

#r相当于匿名函数的参数，当然也可以有多个参数，不用在写return，表达式就是返回的结果。

使用匿名函数有个好处，因为函数没有名字，不用担心函数名冲突，此外匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量调用该函数。