佛曰:
写字楼里写字间，写字间里程序员；
程序人员写程序，又拿程序换酒钱。
酒醒只在网上坐，酒醉还来网下眠；
酒醉酒醒日复日，网上网下年复年。
但愿老死电脑间，不愿鞠躬老板前；
奔驰宝马贵者趣，公交自行程序员。
别人笑我忒疯癫，我笑自己命太贱；
不见满街漂亮妹，哪个归得程序员？
噢耶！！！
一、基础入门
1 注释
# 单行注释
"""
多行注释
"""
2 变量
①变量的分类和声明
在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的
去说明它的类型，系统会自动辨别。也就是说在使用的时候，变量没有类型，数据才有类型。
# 变量的使用
a = 20
b = 12.0
②type()查看变量的数据类型
# 使用type()来检测变量的类型
a = 20
b = 20.0
c = 1 + 5j
d = 'hello world'
e = True
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
③命名规范
-
标识符由字母、下划线和数字组成，且数字不能开头。
-
严格区分大小写。
-
不能使用关键字。
Python的命令规则遵循PEP8标准 - 用下划线“_”来连接所有的单词，比如send_buf.
④关键字
⑤类型转换
常用的几个
补充：chr()：将整数转换为该编码对应的字符串（一个字符）
? 
? ord()：将字符串（一个字符）转换为对应的编码（整数）
代码演示
# 类型转换
a = '2'
b = 30
c = 1
d = ""
l = (29, 230, 23)
f = '[20, 34, 25, 342]'
print(eval(f)) # 将一个对象转换为原来的数据类型，结构就是list类型
print(list(l)) # 将一个系列转化为列表
print(int(a)) # 2
print(float(a)) # 2.0
print(str(b)) # 30
print(bool(c)) # True
print(chr(b)) # RS
print(ord(d)) # 30
?
3 运算符
python的是逻辑与、逻辑非和逻辑非分别是and、or、not
三目元算符（三元运算符）
值1 if 表达式 else 值2 --> 如果if里面是true就输出值1，相反输出值2
print('aaa') if 1 == 1 else print('23243') # 输出aaa
二、流程控制语句
python没有switch
1 for和range
range 可以生成数字供 for 循环遍历,它可以传递三个参数，分别表示 起始、结束和步长
- 起始值默认为0
- 步长为负数是递减，正数是递增
- 步长默认为1
- 不包括结束值，比如 起始0、结束10，那么就是循环9次
代码演示
# 用for循环来遍历
# 小于结束值，步长不写默认为1
for x in range(0, 10):
print(x)
练习
# 循环练习
"""
*
**
***
****
*****
"""
# input方法返回值是字符串类型
row = int(input("请输入行数"))
for i in range(row):
for j in range(i + 1):
# print函数会自动换行，end=表示结尾是什么，比如end=';'，那么最终输出的就会以 ; 结束
print('*', end='')
print()
'''
*
**
***
****
*****
'''
row = int(input("请输入行数"))
for i in range(row):
for j in range(row - 1 - i):
print(" ", end='')
for j in range(i + 1):
print("*", end='')
print()
"""
*
***
*****
*******
*********
"""
row = int(input("请输入行数"))
for i in range(row):
for _ in range(row - 1 - i):
print(' ', end='')
for _ in range(2 * i - 1):
print('*', end='')
print()
2 while
# 玩转while
a = True
b = 1000
c = 1
while(a):
if c > b:
print('程序结束')
break
print(c)
c += 1
三、高级数据类型
1 字符串
① 字符串的写法
# 字符串的写法
str = "孔某是傻逼"
# 这里要注意一下，我们输入空格的话，它输出的时候会连空格一起输出
str2 = """
孔某是某靓仔智的儿子
孔某本身也是个傻逼
"""
print(str)
print(str2)
字符串中使用\（反斜杠）来表示转义
例如：\n不是代表反斜杠和字符n，而是表示换行；而\t也不是代表反斜杠和字符t，而是表示制表符。所以如果想在字符串中表示'要写成\'，同理想表示\要写成\\。
# 转义字符\
str3 = '\'helloWorld\'' # 输出的结果 'helloWorld'
str4 = '\\helloWorld\\' # 输出的结果 /helloWorld/
print(str3)
print(str4)
在\后面还可以跟一个八进制或者十六进制数来表示字符
例如：\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符，例如\u5c0f\u667a代表的是中文“小智”。
# 转义字符后面跟八进制和十六进制
str5 = '\141\142\143\x61\x62\x63'
str6 = '\u5c0f\u667a'
print(str5, str6)
在字符串前面加r，\就不会转义
# 让\不转义
str7 = r'\'abcd\''
str8 = r'\n\\'
print(str7, str8,end='') # 结果显示\'abcd\' \n\\
② 字符串的运算符
+运算符来实现字符串的拼接*运算符来重复一个字符串的内容，in和not in来判断一个字符串是否包含另外一个字符串（成员运算），[]和[:]运算符从字符串取出某个字符或某些字符（切片运算）
代码演示
# 字符串运算符的使用
str = 'hello'
str2 = 'world'
# + 字符串拼接
str3 = str + str2
print(str3)
# in 来判断字符串中是否含有对应的字符，not in相反
boo1 = 'he' in str
boo2 = 'si' in str
print(boo1, boo2) # True False
# 通过[]和[:]取出对应的字符
# [起始:结束] --> 包含起始，不包含结束
str4 = 'asfdsfsd'
print(str4[2]) # f
print(str4[2:4]) # fd
# 也可以这样表示 --> [起始:结束:步长]
print(str4[2::4]) # fs
print(str4[::2]) # afss
print(str4[6::-3]) # sda
# 起始值为负数，从后面数起，不包括起始位置的值
print(str4[-4:-1]) # sfs
③ 格式化输出字符串
# 字符串的格式化
a, b = 5, 10
print('%d * %d = %d' % (a, b, a * b))
# 也可以使用{下标}占位
a, b = 5, 10
print('{0} * {1} = {2}'.format(a, b, a * b))
# 使用f'表达式'来输出
a, b = 5, 10
print(f'{a} * {b} = {a * b}')
④ 字符串函数的使用
# 字符串函数的使用
str = 'hello，world'
# 计算字符串的长度
print(len(str))
# 得到字符串首字母大写的拷贝
print(str.capitalize()) # Hello，world
# 得到每个单词首字母大写字符串的拷贝
print(str.title()) # Hello，World
# 得到全部大写字符串的拷贝
print(str.upper())
# 得到全部小写字符串的拷贝
print(str.lower())
# 查找字符在字符串的索引值
print(str.find('or')) # 7
print(str.find('str')) # 没找到返回-1
# print(str.index('or')) #
# print(str.index('str')) # 没找到会报错，慎用
# 返回字符串中字符出现的次数
print(str.count('o'))
print(str.count('o', 1, 5))
# 检查字符串是否以指定的字符开头，是返回true，否者返回false
print(str.startswith('He')) # False
print(str.startswith('hel')) # true
print(str.startswith('hel', 0, 3))
# 检查字符串是否以指定的字符结束
print(str.endswith('he')) # False
print(str.endswith('world')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str.center(20, '*')) # *******************hello，world********************
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str.rjust(20, '*')) # ***************************************hello，world
# 将字符串以指定的宽度靠左放置左侧填充指定的字符
print(str.ljust(20, '*'))
str2 = 'abc123456'
# 检查字符串是否由数字组成
print(str2.isdigit())
# 检查字符串是否由字母组成
print(str2.isalpha())
# 检查字符串是否由字母和数字组成
print(str2.isalnum())
str3 = ' 23423 @qq.com '
# 获取去除字符串前后空格的拷贝,中间的空格是不会被去除的
print(str3.strip())
print(str3.lstrip()) # 去除左边的
print(str3.rstrip()) # 去除右边的
# 字符串替换后的拷贝，参数1是target，参数2是要进行替换的字符，第3个参数是要替换多少个
print(str3.replace('234', '113', 2))
# 字符串的切割
list1 = str3.split(' ')
# 字符串合并
print('-'.join(list1))
# 判断是否全是空白
str4 = ' '
print(str4.isspace())
print(str.isspace())
2 列表
就是数组
01 快速入门
# 列表入门
salary = [1000, 20000, 3000, 50000]
length = len(salary)
# 第一种遍历方式 --> 通过下角标获取元素
for index in range(length):
print(salary[index])
# 第二种遍历方式 --> 直接遍历元素
for elem in salary:
print(elem)
# 第三种遍历方式 --> 通过enumerate函数可以将下标和元素一起遍历出来
for index, elem in enumerate(salary):
print(index, elem)
补充：
list2 = salary * 2
print(list2) # [1000, 20000, 3000, 50000, 1000, 20000, 3000, 50000]
02 列表的增删改查
① 添加和插入
# 添加和插入元素
list = [2, 34, 22, 54]
# 直接在末尾处添加一个元素
list.append('理解')
# 插入指定位置，如果插入位置大于或者等于数组长度，那么就会插入到最后位置
list.insert(12, '小智')
for elem in list:
print(elem)
② 合并
# 合并两个列表
list = [1, 34, 35, 32]
list2 = [3, 343, 22, 21]
list.extend(list2) # list2会追加到list1后
list2 += [34, 23, 34] # 这种方式也是可以的
print(list)
print(list2)
③ 删除
# 删除元素
list = [1, 2, 3, 4, 4, 3]
# remove移除对应的元素，并不是移除对应下角标的元素
if 4 in list: # 如果4在这个列表中存在，那么就移除
list.remove(4)
if 1234 in list: # 不存在的数据就不会移除
list.remove(1234)
print(list)
# pop是移除指定下角标的元素
list.pop(3)
print(list)
# 清空整个列表
list.clear()
print(len(list)) # 0
④ 切片
# 列表切片
list1 = ['xiaozhi', 'heigui', 'goumo','niuniu']
print(list1[1::]) # ['heigui', 'goumo', 'niuniu']
print(list1[::-3]) # ['niuniu', 'xiaozhi']
print(list1[1:4:2]) # ['heigui', 'niuniu']
print(list1[-3:3:1]) # ['heigui', 'goumo']
03 列表的排序
# 列表的排序
list1 = [23, 34, 22223, 2]
list1.sort() # 将列表正序排序
list11 = [23, 34, 22223, 2]
list11.sort(reverse=True)
print(list1)
print(list11)
list2 = ['yasdff', 'bcsdf', 'yadf', 'sdfsdfsd']
list3 = sorted(list2) # 根据字符串的首字母按字母表的顺序排序
list4 = sorted(list2, key=len) # 有ken=len就是按照字符串长度来进行排序
list5 = sorted(list2, reverse=True) # reverse=True就是逆序
print(list3)
print(list4)
print(list5)
04 生成式和生成器
import sys
# 生成式和生成器
# 第一种方式 --> 这个接收的变量名要一致
f1 = [ x for x in range(1, 10)]
print(f1)
# +号在这里是连接的作用,比如 1 + 2 = 12
# 下面的例子是嵌套循环，要注意
f2 = [x + y for x in 'ABCDE' for y in '1234567']
print(f2)
# **的作用就是次方
f3 = [x ** 2 for x in range(1, 1000)]
print(f3)
# 查看占用的字节数，和c的sizeof作用一样
print(sys.getsizeof(f3))
05 斐波拉切数列
通过yield关键字将一个普通函数改造成生成器函数
# 斐波拉切数列
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
def main():
for val in fib(20):
print(val)
if __name__ == '__main__':
main()
3 元组
元祖的使用方式和列表是类似的，但是不同的是元祖不能修改，列表是可以修改的，元祖使用小括号，列表使用方括号
代码实现
# 元组使用
t = ('小智', 18, True, '广东')
print(t)
# 获取元素中的数据
print(t[0])
print(t[3])
# 遍历元组
for elem in t:
print(elem)
# 将元组转列表
print(type(t))
print(type(list(t)))
f_list = ['service', 'yoy', 'got']
print(type(tuple(f_list)))
元组列表的比较
-
元组不能修改，所以如果需要固定数据的话可以使用元组
-
元组的占用内存是比列表要少的
# 元组和列表的比较 import sys t = (1, 2, 3) l = [1, 2, 3] # 列表的内存时比元组占用的要多 print(sys.getsizeof(t)) # 72 print(sys.getsizeof(l)) # 88 -
元组如果修改的话会报错，这个要注意一下
4 集合
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。
集合是无序的，所以不能通过下角标来取值，同时还去重
①入门
# 集合入门
set1 = {1, 3, 32, 2, 3}
print(set1) # 不会输出重复的数
# 是一个的情况可以不适用占位符
print('Length=', len(set1))
# 创建集合的构造器语法
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 4))
print(set2, set3)
# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)
②添加和删除
# 集合的添加和删除
set1 = {1, 3, 32, 2, 3}
set1.add('4')
set1.update([11, 12]) # 在最后添加
print(set1)
# 取出元素，从第一个开始取，取出原集合就没有这个元素了
print(set1.pop())
# 移除对应元素
set1.remove(1) # 如果不存在对应的数据，那么就会报错
set1.discard(3) # 移除指定的元素,如果没有对应的数据也不会报错
# 上面的功能和下面的功能一样
if 4 in set1:
set1.remove(4)
print(set1)
③交集并集差集运算
# 集合的交集、并集、差集、对称差运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set3 = {1, 2}
# 交集的两种写法
print(set1 & set2)
print(set1.intersection(set2))
# 并集的两种做法
print(set1 | set2)
print(set1.union(set2))
# 差集的两种做法
print(set1 - set2) # 就是set2没有的元素
print(set1.difference(set2))
# 对称差的两种做法
print(set1 ^ set2) # 双方都不一相同的数
print(set1.symmetric_difference(set2))
# 判断子集和超集 --> 是否包含对方，是返回true，否返回false
print(set1 >= set2)
print(set3 <= set1)
5 字典
键值对容器，类似java的map集合，键和值用’:'隔开
# 字典语法练习
# 普通的创建方式 --> 键是要字符串，不能是其他的
student = {'01': '小黑', '02': '黑仔', '03': '傻逼孔'}
print(student)
# 使用构造器的方式来创建
student2 = dict(one='小智', two='小锋', three='小黑')
print(student2)
# 使用zip来将两个序列
student3 = dict(zip(['a', 'b', 'c'], '123'))
print(student3)
# 获取值 --> 通过键来取值
print(student['01']) # 对应的键来取值
print(student.get('02')) # get方法取出
# 遍历，键和值一起输出
for key in student:
print(f'{key}, {student[key]}')
print('{0},{1}'.format(key, student[key]))
print('%s %s' % (key, student[key]))
# 判断是否存在对应的key，存在就取出对应的值
if '01' in student:
print(student['01'])
# 更新字典中的数据
student['01'] = '黑鬼'
print(student['01'])
# 从字典中取出对应的值，取出之后在字典中就没有了，一次只能取出一个
a = student.pop('01')
print(student, a) # 取出指定的key对应的值
print(student.popitem()) # 取出第一个
# 清空字典
student2.clear()
print(student2) # {}
四、函数和模块的使用
01 快速入门
函数的作用就是将重复使用的东西封住起来，使用的时候直接调函数
python中用def关键字定义函数，括号里面是形参，return关键字返回一个值，函数的命名规则和变量名一样
代码演示
# 函数入门
# 定义一个求阶乘的函数
def fac(num):
result = 1
for n in range(1, num + 1):
result *= n
return result
# 调用函数
print(fac(3))
02 函数的参数
python 不支持重载，但是它有替代重载的方案
代码演示
# 函数的参数
from random import randint
def roll_dice(n=2):
"""摇色子"""
total = 0
for _ in range(n):
total += randint(1, 6)
return total
def add(a=0, b=0, c=0):
"""三个数相加"""
return a + b + c
def add2(a, b):
return a + b
# 如果没有指定参数那么使用默认值摇两颗色子
print(roll_dice()) # 我们直接调用的话，传入的参数就是函数形参的默认值
# 摇三颗色子
print(roll_dice(3)) # 有传入形参，那么就使用我们自己的形参
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
# 传递参数时可以不按照设定的顺序进行传递
print(add(c=50, a=100, b=200))
print(add2()) #
注意：如果不传入对应的参数就会使用函数默认的参数，前提是定义的参数它是有默认值的，否者就会报错
可变形参
可变形参时元组类型
# 可变形参
def add(*args):
total = 0
for n in args:
total += n
return total
print(add(1, 2, 3, 4, 5))
03 模块化管理
python是没有重载的，所以如果存在两个重名的函数，后面定义的会覆盖前面定义的，所以如果想要起两个同名的参数，那么我们就需要模块化管理，python中每个文件就代表了一个模块
module1.py
def foo():
print("我是moduler1中的foo")
module2.py
def foo():
print("我是moduler2中的foo")
test.py
# 模块化测试
from module1 import foo
foo() # 我是moduler1中的foo
from module2 import foo
foo() # 我是moduler2中的foo
# 注意：后导入的会覆盖前导入的
from module1 import foo
from module2 import foo
foo() # 我是moduler2中的foo
也可以通过起别名的方式来区分
test.py
# 模块化测试
from module1 as m1
from module1 as m2
m1.foo()
m2.foo()
04 全局变量和局部变量
函数外的就是全局，函数内的就是局部
# 全局变量和局部变量
def foo():
b = 'hello'
# Python中可以在函数内部再定义函数
def bar():
c = True
print(a)
print(b)
print(c)
bar()
# print(c) # NameError: name 'c' is not defined
if __name__ == '__main__':
a = 100
# print(b) # NameError: name 'b' is not defined
foo()
局部变量内修改全局变量
def foo():
global a # global声明的变量就是全局变量，如果全局作用域中没有a，那么下面一行的代码就会定义变量a并将其置于全局作用域
a = 200 # 如果没有global关键字，那么它其实就是一个局部变量，全局变量a不会被修改
print(a) # 200
if __name__ == '__main__':
a = 100
foo()
print(a) # 200
05 函数帮助文档
help(想知道的方法)：得到对应方法的帮助文档
五、面向对象
注意：后导入的会覆盖前导入的
from module1 import foo
from module2 import foo
foo() # 我是moduler2中的foo
也可以通过起别名的方式来区分
```python
test.py
# 模块化测试
from module1 as m1
from module1 as m2
m1.foo()
m2.foo()
04 全局变量和局部变量
函数外的就是全局，函数内的就是局部
# 全局变量和局部变量
def foo():
b = 'hello'
# Python中可以在函数内部再定义函数
def bar():
c = True
print(a)
print(b)
print(c)
bar()
# print(c) # NameError: name 'c' is not defined
if __name__ == '__main__':
a = 100
# print(b) # NameError: name 'b' is not defined
foo()
局部变量内修改全局变量
def foo():
global a # global声明的变量就是全局变量，如果全局作用域中没有a，那么下面一行的代码就会定义变量a并将其置于全局作用域
a = 200 # 如果没有global关键字，那么它其实就是一个局部变量，全局变量a不会被修改
print(a) # 200
if __name__ == '__main__':
a = 100
foo()
print(a) # 200
05 函数帮助文档
help(想知道的方法)：得到对应方法的帮助文档