python-函数，字符串，列表，元组，集合，字典

在python中要交换两个变量的值时，可以直接交换。

eg

    x, y = y, x

函数是绝大多数编程语言中都支持的一个代码的“构建块”,但python中的函数略有不同。如python中的函数的参数可以有默认值。

注：python中无函数重载的概念

对于函数的参数而言我们有时候不确定参数的个数，因此当开发人员不确定时，可以用可变参数。

eg

def add(*args):
    total = 0
    for val in args:
        total += val
    return total

模块:对于python来说一个文件其实就是一个模块，不同的模块中的函数名可以相同只需在使用的时候导入即可。

eg

import module1 as m1
import module2 as m2

m1.foo()
m2.foo()

然而一个不好的地方是，我们再导入一个模块时，如果有可以执行的代码，那么在导入的过程中便会执行这些代码，可我们并不希望如此，因此如果我们在模块中编写了执行代码最好将执行代码放到如下所示的条件中，这样的话除非直接运行该模块否则if条件下的这些代码是不会直接执行的。因为只有直接执行的模块的名字才是“__main__”

eg

# __name__是Python中一个隐含的变量它代表了模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
    print('call foo()')
    foo()
    print('call bar()')
    bar()

在本节中碰到求回文数字的题目，其具有很强的代表性。为解决回文数字的问题，可以将回文数字中的每一个数字分割出来然后倒序放置于一个新的变量中，将该数字与原数字做对比即可得出原数字是否是回文数字。

在大多数语言中都有变量自定义的问题，python也有同样的问题。变量分为全局变量和局部变量。局部变量是不能直接改变全局变量的必须先声明其为全局变量。

eg

def foo():
    global a
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200

python中对于字符串的操作有很多定义，

eg

     用*号可以表示重复输出。

   s1 = 'hello ' * 3
   print(s1) # hello hello hello 

   使用+运算符来实现字符串的拼接。

   s1 = 'hello ' * 3
   s2 = 'world'
   s1 += s2
   print(s1) # hello hello hello world

可以使用in和not in来判断一个字符串是否包含另外一个字符串。

   s1 = 'hello ' * 3
   print('good' in s1) # False

可以用[]和[:]运算符从字符串取出某个字符或某些字符。

str2 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[2]) # c
# 字符串切片(从指定的开始索引到指定的结束索引)
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45

在Python中，我们还可以通过一系列的方法来完成对字符串的处理

  

str1 = 'hello, world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!
# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!
# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!
# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1
# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))
# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True
# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
str2 = 'abc123456'
# 检查字符串是否由数字构成
print(str2.isdigit())  # False
# 检查字符串是否以字母构成
print(str2.isalpha())  # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = '  jackfrued@126.com '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())

以上方法不用刻意去记忆，当用到的的时候查询即可。

使用字符串提供的方法来完成字符串的格式。

eg

a, b = 5, 10
print(f'{a} * {b} = {a * b}')

列表

   下面代码演示了列表的操作

list1 = [1,3,5,7,100]
print(list1)
list2 = ['hello']*5
print(list2)
#计算长度(元素个数)
print(len(list1))
print(len(list2))
#还可以像数组一样直接下标寻址
print(list1[0])
print(list1[3])
#像数组一样直接对某一个元素进行操作
list1[0]=200
print(list1)
#在末尾添加元素
list1.append(400)
print(list1)
#在指定位置添加元素
list1.insert(1,32)
print(list1)
#删除元素
list1.remove(3)
print(list1)
#直接按下标删除
del list1[0]
#按内容删除
list1.remove(32)
print(list1)
#清空列表
list1.clear()
print(list1)

和字符串一样，列表也可以做切片操作。使用方法是一样的。

eg

fruits4 = fruits[-3:-1]
print(fruits4)

当一个列表被创建然后赋值给一个新的列表时，并没有创建新的列表，只是将列表的引用给了新的列表。

eg

fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruit3 = fruits  # 没有复制列表只创建了新的引用

列表排序

eg

list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
# sorted函数返回列表排序后的拷贝不会修改传入的列表
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
list3 = sorted(list1, reverse=True)
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)
# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)

使用列表的生成式语法来创建列表：

f = [x for x in range(1, 10)]
print(f)
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)

使用此种方法虽然很方便，但同时又有一个很现实的问题，过于占内存，因为这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间。为解决这一点，我们决定创建一个生成器对象，当需要的时候可以通过生成器对象获取到数据。同时他也不占用额外的内存空间，但每次需要时需要额外的时间生成需要的数据。

eg

f = (x ** 2 for x in range(1, 1000))
print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
    print(val)

元组

  Python 的元组与列表类似，不同之处在于元组的元素不能修改。

 eg

t = ('Boran', 38, True, 'Aug')
print(t)
# 获取元组中的元素
print(t[0])

# 遍历元组中的值
for member in t:
    print(member)
# 重新给元组赋值
# t[0] = 'Jack'  # TypeError

但元组和列表可以相互转化。

# 将元组转换成列表
person = list(t)

# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)

既然我们已经拥有列表为什么还需要元组那？

1.元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。

2.元组在创建时间和占用的空间上面都优于列表。

集合

Python中的集合跟数学上的集合是一致的，不c素，而且可以进行交集、并集、差集等运算。

set1 = {1, 2, 3, 3, 3, 2}
print(set1)

set1.add(4)

# 将元组转换成集合
set3 = set((1, 2, 3, 3, 2, 1))

字典

以key：value的形式存储数据

eg

scores = {'张三':11,'李四':12}
#通过键获取字典中对应的值
print(scores['张三'])
#对字典进行遍历
for elem in scores:
    print('%s\t-->\t%d'%(elem,scores[elem]))
#更新字典中的元素
scores['王五']=13
print(scores)
scores.update(赵六=14)
print(scores)
#删除字典中的元素
print(scores.popitem())
print(scores.pop('张三'))
#清空字典
scores.clear()
print(scores)