变量是计算机存储数据的内存空间，由于计算机可以处理不同的数据，不同的数据就要定义不同的数据类型。python的数据类型很多，还可以自定义数据类型，常用的一般数据类型有以下几种：
整型：
在python2版本中有long和int之分，但到了python3中就只有int了。
除此之外，整型还有进制的概念：二进制：0b10表示十进制2，八进制：0o10表示十进制8，十进制：10，十六进制：0x10表示十进制16
浮点型：
即float，也就是小数，称之为浮点型是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。
字符串
以"或'括起来的字符，比如："hello, world"。
在表示多行字符串时，可以使用三个单引号(''')/双引号(""")括起来
布尔型
表示的是真或假，通常使用True或False表示。
一些表达式的结果也可以表示真假，如：1 != 2
空的数据类型（""、[]、{}）和None和0表示False，反之为True
复数
如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j，了解即可。
计算机的函数实质上就是一段有特定功能的代码，使用函数可以有效的减少代码的耦合度，同时提高代码的可读性和易维护性。
计算机的函数和数学的函数有一定的相似性：
有参数，相当于数学函数的自变量
有返回值，相当于数学函数的因变量
python 的函数使用def关键词定义，需要写上函数名称，而参数值和返回值需要根据需求考虑是否填写。
如：
def foo(num):return num + 1
前面说过，参数就相当于数学函数的自变量，主要是一些在函数体中用到的值，python的参数可以指定默认的参数。
def pow(num, count=2):"""计算多少次方"""return num ** countif __name__ == "__main__":print(pow(2))# 4print(pow(2, 3))# 8
上面的函数的count参数即指定了默认参数count=2，对于某些对于参数不确定的函数还可以使用不定长参数，其方式一般为*args或**kwargs，这两个参数接收的值的类型分别为list和dict。
def foo(*args, **kwargs): for a in args: print(a) for k, v in kwargs.items(): print(k, v)if __name__ == "__main__": foo(1, 2, 3, **{"a": 4, "b": 5, "c": 6}, d=7)需要注意的是：在传入参数时，可以根据函数参数的位置传参，也可以根据根据参数的关键字传参。二者可以结合使用，但位置参数一定要在关键字参数之前。
比如对于def foo(a, b, c)来说，既可以foo(1, 2, 3)也可以foo(b=2, a=1, c=3)还可以foo(1, c=3, b=2)但不能foo(c=3, 1, 2)。
使用返回值需要用到一个关键词return，一个函数的返回值可以是一个或多个值，也可以是一个函数。
由于python没有函数重载的概念，所以假如定义了相同函数名的函数时，前一个函数会被后一个函数所覆盖：
def foo():print("foo1")def foo():print("foo2")在日常的开发过程中，假如是一个人开发的话可以为不同的函数取不同的名字，但假如是多人开发的话就有可能使用相同的函数名。多人开发时通常使用模块（module）开发，在使用时可以使用import关键字导入某个指定的模块。m1.py:
def foo():print("foo1")m2.py:
def foo():print("foo2")在使用时：
import m1import m2# 使用m1.foo()m2.foo()
需要注意的是：导入模块时会将模块的内容执行一遍，假如不想这样的话，可以使用一个判断语句，使代码主动执行时运行，而不是导入时也运行。
def foo():print("foo")if __name__ == "___main__":foo()__name__是Python中一个隐含的变量它代表了模块的名字，只有被Python解释器直接执行的模块的名字才是__main__。
作用域就相当于一个变量可以使用的范围，该作用域的变量只能本作用域和子作用域可用。有了作用域这个概念就有了全局变量和局部变量这两者变量，全局变量即声明在全局作用域中的变量，而局部变量则不是声明在全局的变量，一般来说是一些函数内部声明的变量。
n = 2# 全局变量def foo():m = 3# 局部变量
根据python的规则，变量会优先找本作用域的，假如找不到会依次往外找，直至找到，当找不到时就会报错。
age = 19def main():print(age)main()
但假如要修改外部作用域的变量时，必须使用global和nonlocal这两个关键字声明一下，否则报错。因为python会认为修改的这个动作其实是声明，也就是说python没有朝外找变量，假如使用变量在声明变量之前的话，就会报错：UnboundLocalError: local variable 'xxx' referenced before assignment。
# 这是错误的示范age = 18def main(): print(age) age = 20main()print(age)
正确的方法：
global
age = 18def main(): global age print(age) age = 20main()print(age)
如果我们希望函数内部的函数能够修改嵌套作用域中的变量，可以使用nonlocal关键字来指示变量来自于嵌套作用域。
2. nonlocal
def test1(): count = 0 def test2(): nonlocal count count += 1 return count return test2() print(test1())
实现计算求最大公约数和最小公倍数的函数。
几个整数中公有的约数，叫做这几个数的公约数；其中最大的一个，叫做这几个数的最大公约数。例如：12、16的公约数有1、2、4，其中最大的一个是4，4是12与16的最大公约数。
实现判断一个数是不是素数的函数
# 第一题 求最大公约数和最小公倍数def gcd(x, y): """最大公约数""" (x, y) = (y, x) if x > y else (x, y) for i in range(x, 0, -1): if x % i == 0 and y % i == 0: return idef lcm(x, y): """最小公倍数""" return x * y // gcd(x, y)# 第二题def is_prime(num): """判断一个数是不是素数""" for factor in range(2, int(num ** 0.5) + 1): if num % factor == 0: return False return True if num != 1 else False
字符串实质上就是由字符组成的有序序列。前面说过字符串是以引号括起来的，引号里面的内容可以使用\进行转义，使一般的字符特殊化，如："\n"表示换行，"\\"表示反斜杠\，除此之外转义符还可以跟八进制（\141）、十六进制（\x61）和Unicode编码。
一些常用的转义符
| 字符 | 含义 |
|---|---|
\ | 在行尾时是续行符 |
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\a | 响铃 |
\b | 退格 |
\e | 转义 |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
除了转义以外，字符串还有很多使用方法。
切片
s = "hello, world"print(s[1:4])
如上所述，切片实质上就是拿中括号写成[开头:结尾:步长]的形式（步长可以省略，且默认为一），把需要截取的一部分内容取出来，不过需要注意的是：切片里面的数不能超过要切片的范围，python的索引以0开始。假如要取开头([:n])或结尾（[n:]）的话，可以空着。
其他方法
python的字符串还有很多的其他方法，这些方法本质上就是一些函数，使用时以"".xxx()的形式调用。
s = "hello world"# 大写print(s.upper()) # HELLO WORLD# 首字母大写print(s.title()) # Hello World# 小写print(s.lower()) # hello world# 替换print(s.replace("world", "world!")) # hello world!# 分割print(s.split(" ")) # ['hello', 'world']# joinprint(" ".join(["hello", "world"])) # hello world# 两边去空print(" hello world ".strip()) # hello world# 查找# 找的是第一个的位置，用rfind可以找最后一个print(s.find("l")) # 2# print(s.index("t")) # 找不着时会报错# 判断开头、结尾print(s.startswith("hello")) # Trueprint(s.endswith("ld")) # True列表也是python的一种常用的数据结构，上面例子中split方法的结果就是一个列表。列表由一个个元素组成，各个元素的类型可以各不相同，与字符一样，列表可以切片、也有一些特定的方法，不一样的是，列表可以直接通过索引对元素进行修改，而字符串则不可以。
fruits_list = ["apple", "pear", "peach", "banana"]print(fruits_list[1:]) # ['pear', 'peach', 'banana']# 修改值fruits_list[2] = "orange" # ['apple', 'pear', 'orange', 'banana']# 追加fruits_list.append("pear") # ['apple', 'pear', 'orange', 'banana', 'pear']# 插入# 第一个参数是位置，第二个参数是要插入的元素fruits_list.insert(0, "cherry")# ['cherry', 'apple', 'pear', 'orange', 'banana', 'pear']# 迭代添加一个列表fruits_list.extend(["watermelon", "lemon"])# ['cherry', 'apple', 'pear', 'orange', 'banana', 'pear', 'watermelon', 'lemon']# 删除# 按索引位置删除fruits_list.pop(0)# ['apple', 'pear', 'orange', 'banana', 'pear', 'watermelon', 'lemon']# 删列表中的第一个指定值fruits_list.remove("pear")# ['apple', 'orange', 'banana', 'pear', 'watermelon', 'lemon']# 排序# 可以跟匿名函数lambda：fruits_list.sort(key=lambda x: len(x))fruits_list.sort()# ['apple', 'banana', 'lemon', 'orange', 'pear', 'watermelon']# 查找# 第一个指定值的位置print(fruits_list.index("pear")) # 4# 清空fruits_list.clear() # []元组是一种类似于列表的数据结构，它以小括号()括起来为一个元组，元组的元素同样可以是任意的。但是需要注意的是，元组的元素并不能被改变，这一种特性这某些场合中适用，如某些重要的数据、不允许改变的类属性(__slots__)和函数的多返回值。由于元组不能被修改，所以我们只需要关注其定义和使用即可。
# 定义元组fruits_tuple = ("apple", "pear", "peach", "banana")# 也可以使用tuple从其他可迭代数据转换过来fruits_tuple = tuple(["apple", "pear", "banana", "peach", "banana"])print(fruits_tuple)# 遍历for f in fruits_tuple: print(f)# 计数print(fruits_tuple.count("banana")) # 2# 查找print(fruits_tuple.index("banana")) # 2元组在内存上比列表更小，换句话说使用元组可以节省内存，使用sys.getziseof函数可以返回该对象的字节数。
import sysprint(sys.getsizeof(("apple", "pear", "peach", "banana"))) # 72print(sys.getsizeof(["apple", "pear", "peach", "banana"])) # 88字典是由一个个键值对组成的数据结构，它以大括号（{}）括起来为一个数据，一般的形式为：{"key": "value}。需要注意的是，字典的键不能重复，也就是说，假如再次给已经存在的键赋值时，原来的值会被替换；而且键是可以被哈希的数据，一般来说，python不可变的内置类型都可以被哈希，而列表和字典是可变的，不可被哈希，所以不能作为集合的元素。。
data = { "name": "lczmx", "age": 18, "address": "xxx",}# 获取# 1. 使用中括号，类似于索引的方法，假如没有该键的话会报错print(data["name"]) # lczmx# 2. 使用get方法,没有该键时，返回另一个参数print(data.get("name", "none")) # lczmx# 3. 获取键值对for k, v in data.items(): print(f"key: {k} value: {v}")# 4. 获取键或值for k in data.keys(): print(f"key: {k}")for v in data.values(): print("value: %s" % v)# 更新# 1. updatedata.update({"score": 99, "student": True})# 写法一data.update(score=99, student=True)# 写法二# {'name': 'lczmx', 'age': 18, 'address': 'xxx', 'score': 99, 'student': True}# 2. fromkeys# 将一个可迭代的数据的元素作为键，为多个键创建统一的值# 注意，这是dict的方法d2 = dict.fromkeys(["a", "b", "c"], "123")print(d2) # {'a': '123', 'b': '123', 'c': '123'}# 3. setdefault# 存在取对应的值，不存在则新增键值对print(data.setdefault("name", "lczmx")) # lczmx# 删除# 1. 随机删除,返回被删除的键值对print(data.popitem()) # ('student', True)# 2. 删除键对应的值，不存在时返回的二个参数print(data.pop("name", "already delete")) # lczmx# 3. 清空data.clear()print(data)# {}python的集合与数学上的集合是一样的，有交集、差集、并集、补集等操作，而且元素是唯一无序的。注意：元素的类型不可变的，准确的说：可以被哈希的数据类型可成为元素。根据集合的这些特性，一般来说其用途一般有两个方面：1. 关系测试（相交等）、2. 去重。
fruits1 = {'cherry', 'pear', 'banana', 'watermelon', 'lemon'}fruits2 = set(['apple', 'pear', 'banana', 'orange'])# 添加fruits2.add("lemon")# 交差并集可以用方法实现，也可以用符号实现# 交集print(fruits1.intersection(fruits2))print(fruits1 & fruits2)# {'banana', 'lemon', 'pear'}# 差集print(fruits1.difference(fruits2))print(fruits1 - fruits2)# {'watermelon', 'cherry'}# 并集print(fruits1.union(fruits2))print(fruits1 | fruits2)# {'banana', 'orange', 'pear', 'cherry', 'watermelon', 'lemon', 'apple'}# 删除# 1. remove# 删除指定元素，不存在则报错fruits1.remove("banana")# 2. discard# 删除指定元素，不存在不报错fruits1.discard("apple")假如定义的时候用forzenset定义的话，则该集合不可变。
推导式是一种构建数据的快捷方式，假如用得好可以简化代码，提高可读性。但假如滥用推导式，就有可能降低代码可读性。一般来说，超过两个for循环的代码，就不适合用推导式了，而直接用多个循环写了。
顾名思义，即生成列表的推导式，和定义列表一样，列表推导式用中括号包裹着表达式。
假如有这样一个需求：
把num = [18, 22, 23, 50]里面的数加一，我们固然可以，使用一个for循环把每个元素加一，然后放回原来的列表中。但使用列表推到式只需要一行代码即可：num = [n + 1 for n in num]。
上面的例子只有一个循环，但假如多个循环该怎么做，如果现在有num和code两个列表：
num = [1, 2, 3, 4, 5]code = ["A", "B", "C", "D"]
要求他们相互组合成['A1', 'A2', 'A3', 'A4', 'A5', 'B1', 'B2', 'B3', 'B4', 'B5', 'C1', 'C2', 'C3', 'C4', 'C5', 'D1', 'D2', 'D3', 'D4', 'D5']。
很简单：
num = [1, 2, 3, 4, 5]code = ["A", "B", "C", "D"]result = [c + str(n) for c in code for n in num]print(result)
python2.7的版本中使用列表推导式有可能有变量泄露的风险，但在python3中则没有该顾虑，可以放心使用。
虽然可以使用列表推导式初始化元组等其它序列类型，但是生成器表达式是更好的选择。由于生成器遵循迭代器协议，可以在用到时才生成元素，可以减少内存开销。生成器表达式在书写上与列表推导式仅仅是把中括号换成了小括号。
比如同样是上面的那个例子：
import sysnum = [1, 2, 3, 4, 5]code = ["A", "B", "C", "D"]result_list = [c + str(n) for c in code for n in num]result_tuple = tuple([c + str(n) for c in code for n in num])result_gen = (c + str(n) for c in code for n in num)print(sys.getsizeof(result_list), sys.getsizeof( result_tuple), sys.getsizeof(result_gen))# 256 200 112
使用生成器除了可以用生成器表达式，也可以用yeild关键字：
def gen_result(): num = [1, 2, 3, 4, 5] code = ["A", "B", "C", "D"] for c in code: for n in num: yield c + str(n)for i in gen_result(): print(i)
自python2.7以来，列表推导式和生成器表达式的概念就移植到了字典上（集合也一样），因此就有了字典推导式。使用字典推导式可以将可迭代的数据作为键值对构建出字典。
例子：
temp = ["A1", "B2", "C3", "D4"]result_dict = {c: n for c, n in temp}print(result_dict) # {'A': '1', 'B': '2', 'C': '3', 'D': '4'}假如是由两个可迭代数据组成字典的话，可以使用zip函数：
num = ["1", "2", "3", "4"]code = ["A", "B", "C", "D"]result_dict = dict(zip(code, num))print(result_dict) # {'A': '1', 'B': '2', 'C': '3', 'D': '4'}集合推导式跟列表推导式用起来差不多，下面举个简单的例子即可：
num = ["1", "2", "3", "4"]code = ["A", "B", "C", "D"]result_set = {c + str(n) for c in code for n in num}print(result_set)# {'D3', 'C3', 'A2', 'D1', 'C1', 'C2', 'B4', 'B2', 'B3', 'C4', 'A1', 'D2', 'D4', 'A3', 'B1', 'A4'}在屏幕上显示跑马灯文字。
import timedef main(): string = "放飞你的青春，奔洒你的热情。 " while True: print("\r%s" % string, end="") string = string[1:] + string[0]# 把第一个字符放到最后一个，以达到运动的效果 time.sleep(0.2)if __name__ == '__main__': main()设计一个函数产生指定长度的验证码，验证码由大小写字母和数字构成。
import randomdef veri_code(count=4): chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' temp = "" for _ in range(count): temp += random.sample(chars, 1)[0] return tempdef main(): print(veri_code())if __name__ == '__main__': main()
设计一个函数返回给定文件名的后缀名。
def get_suffix(filename): if "." in filename: return filename.split(".")[-1] else: return ""设计一个函数返回传入的列表中最大和第二大的元素的值。
def get_max(data: list): max1 = 0 # 最大 max2 = 0 # 第二大 for d in data: if d > max1: max2 = max1 max1 = d else: if d > max2: max2 = d return max1, max2
打印杨辉三角。
def triangles(): L = [1] while True: yield L L = [sum(i) for i in zip([0] + L, L + [0])]# zip和sum结合，不过要在两边加0
联系客服
