[Python] 基础篇-实用语法操作

Posted 2020-12-15 萧蔷ink

• 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
","hello china
"]

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(‘@‘,"
")

• 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‘} <class ‘dict‘>
#关键字参数允许传入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，表达式就是返回的结果。

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