Python基础教程

python的基础认识

什么是编程

• 编程：用代码编写程序

• 编程语言：用哪种语法规则来编写程序

编程语言分类

• 编译性：一次性把源代码进行编译，执行效率很高，平台依赖性比较高

• C语言，go语言

• 解释性：逐行对源代码进行编译和运行，执行效率相对性较低，源代码一般无法加密，对平台依赖性不高

• javascript，python，ruby

什么是python？优缺点？

• python是一个叫龟叔的荷兰老头在89年写的

• 擅长：爬虫，自动化，科学计算，人工智能

python解释器安装

• 官网(Welcome to Python.org)

第一个python文件安装

• 进入cmd，输入python

如何调用python文件

• cmd里直接 python 文件路径

pycharm安装

写python的工具

1. 记事本

2. vscode

3. pycharm

4. jupyter notebook

pycharm

• 官网下载(下载 PyCharm：JetBrains 出品的用于数据科学和 Web 开发的 Python IDE)

注释

• 注释是对代码进解释和说明

• 注释是给人看的，机器不运行的

python的注释

• #号 + 内容

• """内容""":多行注释

• '''内容''':多行注释

• （font：字体）

变量

• 变量：可以发生改变的一个量，变量是用来区分不同数据的，可以指向一个内存空间

• 变量的命名：

  1. 必须是数字或下划线或字母组成

  2. 但是不能数字开头，更不能是纯数字

  3. 不要用中文

  4. 不能用python的关键字

  5. 不要太长

  6. 要有意义

  7. 推荐使用下划线命名或者驼峰命名法

常量

1. print（123）

2. 可以把所有的变量的字母变成大写就可以认为是常量（主观上是常量但是在python中是不存在绝对意义的常量）

初识基础数据类型

数据类型的作用

• 区分不同的数据，不同的数据类型应该有不同的操作

数字

1. +-*/

2. 整数：int类型

3. 小数：float类型

文字

1. 字符串:str类型 可以用“”或者‘’包裹起来 长字符可以用‘’‘或者“”“来包裹

2. 可以 加法和乘法

布尔

条件判断

1. True 真

2. False 假

最简单的用户交互

input

1. 语法

   1. input（提示语）

   2. input 得到的结果一定是字符串

type：查看一个变量的数据类型

• py基础类型：

• 想把xxx装换成谁，就用谁套起来

• str=> int（str）

条件判断

if语句的语法规则:

一：

• if 条件:

• 代码

• 如果条件成立就执行代码如果不成立，就不执行

二：

• if 条件:

• 代码1I

• else:

• 代码2

• 如果条件成立，执行代码1，否则，执行代码2

三：if语句可以互相嵌套

• if 条件:

• if.....

• SS

• else:

• XX

• else:

• 代码2

四：

if 条件:

代码1

elif 条件2: 代码2 elif 条件3: 代码3 else：

if a > b:
    print("a大于b")
elif a < b:
    print("a小于b")
else:
    print("a等于b")

循环语句

while

• while循环可以让我们的代码重复的去执行

• 语法：

• while 条件：

• 代码

• 过程：判断条件是否为真，如果真，执行代码，直到条件为假

i=1
s=0
while i <= 100:
    s += i
    i = i + 1
    print(s)
​
ti = ["zhangsan"]
while True:
    so = input("请输入:")
    if so == "q":
        break
    if so == 'sb':
        print("不能骂人")
        continue
    else:
        print("发送给" + ti[0] + ':' + "\n" + so)
        break

break和continue

• break能让循环停止

• continue停止当前循环，继续执行下一次循环

for循环

• range（x）这是一个数组使用for循环时会从0到x，不包括x

• range（x，y）从x到y

• range（x,y,z）从x到y，步长z

• for 变量 in 可迭代的东西：

• 代码

• 把可迭代的东西中的每一项拿出来，挨个的赋值给变量

第一章补充

pass

• 效果是过，意义是代码占位

• 主要作用是在未写好代码时带过

  s=1
  if s==0:
      pass
  else:
      print('no')

第二章 基础数据类型

1. int 整数，加减乘除，大小比较

2. float 小数，浮点数

3. bool 布尔，条件判断，范围只有真假，基础类型的转换

4. 在python中表示空的东西都是false，不空就是true

字符串

1. 字符串的格式化问题

   1. %s 字符串占位

   2. %d 数字占位

   3. %f 小数占位

字符串的3种操作

​
s = '我叫%s，我住在%s，我今年岁%d，我喜欢%s' % (name, addwe, age, haowan)
​
m = '我叫{}，我住在{}，我今年岁{}，我喜欢{}'.format(name, addwe, age, haowan)
​
p = f'我叫{name}，我住在{addwe}，我今年{age}岁，我喜欢{haowan}'

索引和切片

索引

1. 按照位置提取元素

2. 可以通过索引提取字符（文字）

切片

1. 从一个字符串中提取一部分内容

s = '我叫王建,我住在安居客,我今年18岁,我喜欢大猫'
m = '我爱你'
​
print(s[0:26]) 
print(s[2:]) 
print(s[:26])
print(m[::-1])#切片（前闭后开区间）(第二个：后面是步长，-号是改变默认的从左往右逻辑，变为从右往左)
​
print(s[0]) #索引
​
print(len(s)) #遍历数组（len）

字符串的常规操作

1. 字符串的操作一般不会对原字符串产生影响，一般是返回一个新的字符串

s = 'python'
​
s1 = s.capitalize()
​
print(s1) #capitalize的作用是首字母大写
​
m = 'I love you'
m2 = m.title()
print(m2) #title的作用是句子中每个单词的首字母大写
​
#lower/upper 所有的字母变成小/大写

# 如何忽略大小写来进行判断
​
x = "xAd1"
​
b = input(f"请输入验证码({x}):")
​
if x.upper() == b.upper():
    
    print('验证码正确')
    
else:
    
    print('验证码不正确')

字符串的切割和替换

1. strip() 去掉字符串左右两端的空白符

2. replace(old,new) 字符串替换

3. split() 字符串切割 切割后的结果会放在列表当中，用什么切就会损失什么

username = input('username:').strip()
password = int(input('password:').strip())
m = len(username)
if m < 5:
    print('用户名长度不对')
    exit()
elif username == 'admin':
    if password == 123456:
        print('登陆成功')
    else:
        print('登陆失败')
else:
        print('用户名不存在')

w = "你 这 个 傻 逼 "
w1 = w.replace('傻 逼', '帅哥')
w2 = w1.replace(' ', '')
print(w2)

a = 'python_java_c_php'
b = a.split('_')
print(b)

字符串的查找和判断

1. 查找： find 和 index （如果返回是-1/报错 就是没有字符串）最常用的一种是 print('py' in a) print('py' not in a) （True就是有False就是没有）

2. 判断： startswith 判断字符串是否以什么开头

3. isdigit 判断是否用整数组成

   s = input("name")
   if s.startswith('张'):
       print(1)
   else:
       print(0)

   s = input("数字")
   if s.isdigit():
       s = int(s)
       print('是数字')
   else:
       print('不是数字')

字符串的总结和补充

ls = ['wan', 'shu', 'hang']
ls1 = '_'.join(ls)
print(ls1)

1. join：连接字符串

列表

1. 定义：能装东西的东西

2. python中用[]来表示一个列表，列表中的元素用 ， 隔开

3. 特点： 也像字符串一样能索引和切片 如果索引超出范围就会报错 for循环遍历

mmd = ['a', 'b', 'c']
y = len(mmd)
u = len(mmd[0:4])
o = len(mmd[::-1])
for s in mmd:
    print(s)
print(y)
print(u)
print(o)

列表的增删改查

1. 添加内容： .append（直接在最后加） .insert(第几个位置，加入内容 ) txend 合并两个列表，批量添加

2. 删除 ：.pop 删除一个元素（数字款） .remove （字符款）

3. 修改： 直接索引就可以修改

4. 查询： 直接索引就可以查

mmd = ['a', 'b', 'c']
mmd.append('d')
mmd.insert(0,'e')
mmd.extend(['r', 'i'])
mmd.pop(1)
mmd.remove('e')
mmd[2]='m'
print(mmd)

mmd = ['打打电话', '大大大', '哒哒哒', '大大哇']
for i in range(len(mmd)):
    op = mmd[i]
    if op.startswith('大'):
        oop = '小' + op[1:]
        print(oop)
        mmd[i] = oop
print(mmd)

• 这是一个更改列表某个字符的代码

列表的补充

• 排列

le = [1,2,3,'完','大大']
le.sort()#对列表升序排序
le.sort(reverse=True)#reverse翻转 效果降序

• 列表的嵌套

k = ['o',['p',1,[2]]]
print(k[1][2][0])

元组

1. tuple ：特点 不可变的列表 t = ("zhangsan", "lisi")

set(集合)

1. set集合是无序的

2. 不可哈希：unhashable ，在python中的set集合进行数据存储的时候，需要对数据进行哈希计算，必须可以进行哈希计算 ， 可哈希：不可变的数据类型：int ，str, tuple， bool

3. 创建空：

   1. s= set()

   2. s=xxx()

• 添加：.add

• 删除： .pop （由于集合无需，测试的时候没法验证最后一个）

• 想要修改，先删除，在新增 .remove

• for循环查询

set集合的补充

1. 交集

2. 并集

3. 差集

s = {1, 2, 3}
s1 = {1, 4, 5}
print(s & s1)  # 交集
print(s.intersection(s1))
print(s | s1)  # 并集
print(s.union(s1))
print(s1 - s)  # 差集
print(s.difference(s1))
# 集合重要作用可以去除重复，集合里不能有两个一样的

字典

1. 首先字典是一键值对的形式进行储存数据的

2. 字典的表示方式：{key:value, key:value} 字典的key必须是可哈希的 value可以放任何类型

vu = {"zhangsan": "123345"}
print(f'我的手机号是{vu['zhangsan']}')

字典的增删改查

• 增，改

xu = dict()
xu['zhangsan'] = ['123456']
xu[1] = [2]
xu['zhangsan'] = ['2356']
xu['tom'] = ['9999']
xu.setdefault('tom', "胡辣汤")  # .setdefault 设置默认值，如果已经有了就不起作用
print(xu)

• 删除

xu.pop('tom')
​
del xu['tom']

• 查询

print(xu['tom']) #如果不存在会报错
print(xu.get('tom')) #不存在输出none

字典的循环和嵌套

• 循环

mo = {
    '老张': '有钱',
    '老六': '可六',
    '老鳖': '可瘪'
}
​
for jj in mo:
    print(jj + '他' + mo[jj])
    print(jj, mo[jj])
​
​
for io in mo.items():
    key = io[0]
    value = io[1]
    print(key, value)
​
for key, value in mo.items():
    print(key, value)

• 把所有的key/value/key&&value放到一个字典里

print(list(mo.keys()))
print(list(mo.values()))
print(list(mo.items()))

• 嵌套

laowang = {
    "name": "汪峰",
    "gongzuo": "唱歌",
    "qizi": {
        "name": "王嬷嬷",
        "gongzuo": "跳舞",
        "zhuli": {
            "name": "肖恩",
            "age": "28",
            "aihao": "打游戏"
        }
    },
    "haizi": [
        {"haizi1": "汪墙", "age": "18"},
        {"haiz2": "汪九", "age": "12"}
    ]
}

字典的循环删除

1. 字典的直接循环删除是有问题的，所以要使用列表存储在使用删除

mo = {
    '老张': '有钱',
    '老六': '可六',
    '老鳖': '可瘪',
    'zhang': "123"
}
li = list()
for key in mo:
    if key.startswith("z"):
        li.append(key)
for i in li:
    mo.pop(i)
print(mo)

none

• '空' （类型）单纯就是空

解包

1. 元组和列表都可以执行该操作

a, b = (1, 2)
print(a)
print(b)
​
for io in mo.items():
    a, b = io
    print(a, b)

字符集和编码

1. 0 1 <=>1010101010 =>二进制转化成十进制<=> 88

2. 电脑如何进行存储文字信息

   1000000 <=>a

3. ascii =>编排了128个文字符号，只需要7个0和1就可以表示了。

   01111111 =>1 byte => 8bit

4. ANSI =>一套标准，

   每个字符 16bit，2byte

   00000000 01111111

5. 到了中国，gb2312编码，gbk编码（windows默认）

   到了台湾，big5编码

   到了日本，JIS编码

6. Unicode：万国码

   1. 早期Unicode没有意识到这个问题，UCS-2 2个字节

   2. 进行了扩充，UcS-4 4个字节

   3. 00000000 00000000 00000000 01111111

   4. utf:是可变长度的unicode。可以进行数据的传输和存储 -> 行书，草书，隶书

   5. utf-8:最短的字节长度8

      英文:8bit，1byte

      欧洲文字:16bit，2byte

      中文:24bit，3byte

   6. utf-16:最短的字节长度16

7. 总结:

   • ascii: 8bit, 1byte

   • gbk:16bit，2byte windows默认

   • unicode:32bit，4byte(没法用，只是一个标准)

   • utf-8: mac默认

     英文:8bit，1byte

     欧洲:16bit，2byte

     中文:24bit，3byte

   • gbk和utf-8 不能直接就进行转化

8. bytes:

   • 程序员平时遇见的所有的数据最终单位都是字节byte

s = "周杰伦"
bs1 = s.encode("'gbk")  # b'xxxx' bytes类型
bs2 = s.encode("utf-8")
print(bs1)
print(bs2)
​
# 怎么把一个gbk的字节转化成utf-8的字节
bs = b'\xd6\xdc\xbd\xdc\xc2\xd7'
# 先变成文字符号(字符串)
m = bs.decode('gbk')  # 解码
print(m)
bs3 = m.encode('utf-8')  # 重新编码
print(bs3)

运算符

1. 算术运算

   • +—*/

2. 比较运算

   • < > >= <= == !=

3. 赋值运算

   • = += -= *= /=

   • a+=b == a=a+b

4. 逻辑运算

   • and , 并且 ，左右两端成立才成立

   • or ， 或者 ， 左右两端有一个成立就是成立

   • not ， 非 ，非真及假，非假及真

   • 当三者一起出现，最好有括号，没有括号

     • 先算括号 > 算not > 算and > 算or

5. 成员运算

   • in

   • not in

文件操作

1. open（文件路径， mode="目的"，encoding="编码"） -----打开文件

2. 绝对路径/相对路径 d:/uer/maomao/appdata / 相对于当前你的程序所在文件夹

3. mode: r:read 读取 w:write 写（如果文件不存在创建一个文件) a:append 追加写入

4. .close(关闭)

p = open('./xiedewenjian.txt', mode='r', encoding='utf-8')
# p1 = p.read() #读全部
# p2 = p.readline() #读取一行
# p3 = p.readline().strip() #去掉空白符
# p4 = p.readlines() #以一行为单位全部读取
for p3 in p:
    print(p3)  # 全部读取并且一行一行的读取

p = open('./xiedewenjian.txt', 'w', encoding='utf-8')
p.write('胡辣汤')  # w模式是删除文件内容，再写入
p.close()

• with (with打开文件不用手动关闭了)

• 在读取非文本文件的时候用b模式

• 文件的复制

with open("湖一菲.jpeg",mode="rb") as f1,\
open("../01_初识python/胡二飞.jpeg",mode="wb") as f2:
    for line in f1:
        f2.write(line)

• 文件的修改

with open("./xiedewenjian.txt", mode="r", encoding='utf-8') as f1, \
        open("./xiewenjian2.txt", mode="w", encoding='utf-8') as f2:
    for o in f1:
        o1 = o.strip()
        if o1.startswith("胡"):
            o1 = o1.replace('胡', '牛肉胡')
        f2.write(o1)
        f2.write("\n")
# 删除源文件更改文件名
import os #引入os库
​
os.remove('xiedewenjian.txt')
os.rename('xiewenjian2.txt', 'xiwenjian.txt')

函数的概述

函数的定义

• 函数：对某一个特定代码或功能进行封装

• 定义： def 函数的名字（）：

  代码块或函数体

• 使用 函数的名字（）

函数的参数

• 参数：可以在函数调用的时候，给函数传递一些信息

• 形参，在函数定义的时候给定一些变量来接受信息

• 实参，实际在调用的时候传递的信息

实参的分类

1. 位置参数，按照位置进行传参

2. 关键字参数，按照参数名字进行传递参数

3. 混合参数：顺序：位置参数放前面关键字参数放后面

• 实参在执行的时候一定要有参数

形参的分类

1. 位置参数，按照位置一个一个去声明设置

2. 默认值参数，在函数声明的时候给变量一个默认值，如果实参不传信息就使默认值生效，否则不生效

3. 当两个一起顺序为：位置参数在前默认值在后 位置 > 默认值

4. *：动态传参：表示位置参数的动态传参，接收到的值会被统一放到一个元组里面（**）：表示关键字的动态传参

5. 顺序：位置>*args>默认值>**kwargs

6. 在实参位置前加上*是把列表打散成位置参数进行传递 **是把字典转化~~

函数的返回值

1. 返回值：return 函数执行之后，会给调用方一个结果，这个结果就是返回值

2. 关于return: 函数只要执行到了return. 函数就会立即停止并返回内容， 函数内的return的后续的代码不会执行

   如果函数内没有return此时外界收到的是None

   如果写了return

   只写了return,后面不跟数据，此时接收到的依然是None

   return 值 此时表示函数有一个返回值，外界能够收到一个数据

   return 值1，值2，值3.....， 此时函数有多个返回值，外界收到的是元组，并且，该元组内存放所有的返回值

内置函数

1. bin 2进制

2. oct 8进制

3. hex 十六进制

4. sum

5. min

6. max

7. pow

8. format 格式化

   a=18 print(format(a，"@8b")) # b: 二进制， o: 八进制，x: 十六进制

9. ord python中内存中使用的是unicode

10. chr 给编码位置展示文字

    print(ord('中'))
    print(chr(20013))

11. all 当成and来看

12. any 当成or来看

    print(all([0, '123']))
    print(all([1, '123']))
    print(any([0, '123']))

13. enumerate 可以直接拿到索引位置和元素

14. hash 哈希运算 一定是一个数字 ->然后进行数据的存储 -> 字典(集合)哈希表

15. id 直接查看内存地址

16. dir 能告诉你当前数据能执行那些操作

函数下

作用域

• 作用域：变量的访问权限

  1. 全局变量————全局作用域

  2. 在外面定义的变量是可以在函数里访问到的，在内部的变量叫做局部变量--局部作用域，外面访问不到，但是可以通过return返回后访问

• global 把外面的全局变量引入局部变量

• nonlocal 把外层局部变量引入当前局部变量

闭包

• 可以让一个变量常驻与内存

• 避免全局变量被修改

• 本质：内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数

def ok():
    a = 0
    def ook():
        nonlocal a
        a += 1
        return a
    return ook
​
​
ko = ok()
​
k1 = ko()
print(k1)
k2 = ko()
print(k2)

装饰器

1. 函数可以作为参数返回

2. 函数可以作为返回值进行返回

3. 函数名称可以可以当成变量一样进行赋值

4. 装饰器本质是一个闭包 作用：在不改变原有函数调用的情况下，给函数添加新的功能。（在函数前后添加新功能但不改变源代码）

def wan(fn):
    def zhe():  
        fn()
    return zhe

参数问题&&返回值问题

def wan(fn):
    def zhe(*args, **kwargs):#传参问题
        print("开挂")
        ty = fn(*args, **kwargs)#返回值问题
        print("关闭外挂")
        return ty #返回值问题
​
    return zhe
​
​
@wan
def wangzhe(uersname, password):
    print(f"验证密码{password}正确")
    print(f"使用{uersname}打王者")
    return "上星10颗"
​
​
po = wangzhe("maomao", 12345)
print(po)

迭代器

1. 可迭代的数据类型都会提供一个叫迭代器的东西，这个迭代器的可以帮我们把数据类型中的数据逐一的拿到

2. iter（）内置函数可以直接给我们拿出迭代器 .__iter__()

3. 从迭代器拿数据 next（）内值函数.__next__()

4. for里面一定是要拿迭代器的，所以所有不可迭代的东西不能用for循环 for循环里面一定有_next出现 总结: 迭代器统一了不同数据类型的遍历工作

生成器

• 生成器就是迭代器

• 生成器函数，生成器表达式

• 关键字：yield 有返回的意思，当执行时才反回

• 生成器函数执行的时候，并不会执行函数，得到的是生成器

• yield的作用 可以返回函数 可以分段执行函数中的内容，通过__next__()可以执行到下一个yield的位置

推导式

• 简化代码

• 语法： 列表推导式： [数据 for if判断 ] lst = [i for i in range(10)] print(lst) 集合推导式{} 字典{key：value}

生成器表达式

gen = (i**2 for i in range(100))
#print(gen.__next__())
#print(next(gen))
for i in gen:
    print(i)

匿名函数

• lambda表达式

• 变量 = lambda 参数一，参数二 ：返回值

• fn = lambda a,b : a+b (ro = fn(12,15))

类（自己补充）

• # class 类名(在定义类名的时候使用的是首字母大写的命名方法):
  class CuteCat:
      # 构造函数第一个参数是self表示函数自身用于把属性绑定在实例对象上
      def __init__(self):
          self.name = 'maomao'
  ​
  ​
  cat1 = CuteCat()
  print(cat1.name)#打印cat1绑定的name值

class CuteCat:
    # 构造函数第一个参数是self表示函数自身用于把属性绑定在实例对象上
    def __init__(self, name, age, color):
        self.name = name
        self.age = age
        self.color = color
​
​
cat1 = CuteCat("maomao", 2, 'red')

super（）调用父类