Python基础教程（非新手向）

前言

这篇博客主要是提供给已经学过C++或java等已经有编程基础的同学的
内容可能比较硬核，望谨慎观看（/doge 手动狗头保命）

一、简单的输入输出

1.输入

控制台会输出“请输入”，输入后的数据以字符串的形式传入,可以强制类型转换为int

x=int(input("输入： "))

2.输出

格式化输出用format()

1. 指定位置，不指定则为默认位置

   print("{1} {0} {1}".format("hello", "world"))
   

2. 设置参数

   print("名称：{name}, 年龄 {age}".format(name="x", age="1"))
   

3. 通过字典设置参数

   dic = {"name": "x", "age": "1"}
   print("名称：{name}, 年龄 {age}".format(**dic))
   

4. 通过列表设置参数

   list = ['x', '1']
   print("名称：{0[0]}, 年龄 {0[1]}".format(list))  # "0" 是必须的
   

3.格式化数字

二、基础语法

1. if语句

   if condition_1:
       statement_block_1
   elif condition_2:
       statement_block_2
   else:
       statement_block_3
   

2. 循环语句

   while <expr>:
       <statement(s)>
   else:
       <additional_statement(s)>
   
   for <variable> in <sequence>:
       <statements>
   else:
       <statements>
   
   

三、变量类型

前情提要

1. 变量分类：
   - 可变：list、dictionary（字典）
   - 不可变：number、string、set、tuple（元组）

2. 变量不需要声明

3. 允许多变量赋值：a,b,c=1,2.3,“x”

4. type(查看数据类型)

1、运算符

基本都相同，增加了几个：

1. x//y: 向下取整，数据类型取决于y
2. x**y: pow(x,y)
3. is: 是不是引用自同一个对象（==是判断值)
4. in：指定序列里能否找到

2.number

不允许改变，如果要改变值，就是重新分配内存空间
例如
a=1
a=2
那么两个a就不是同一个内存地址
常用内置函数：max、min、pow、abs

3.字符串

类似于java里的String，是不可变的

1. +：用于字符串拼接

2. *：重复字符串

3. in：类似于find

4. r"string"：原始字符串，不翻译转义符

5. f"string"：字符串中的表达式用{}包起来，表达式替换

   name = 'Runoob'
   print(f'Hello {name}')  # 替换变量
   print(f'{1+2}')
   

6. 常用内置函数：
   - count：查找出现次数
   - startswith、endswith：是否以str开始或结束
   - find：查找，返回索引
   - isdigital：如果值包含数字返回true
   - len：字符串长度
   - max、min：返回最大最小字母
   - replace：替换
   - split：按照str拆分
   - s.join（x）：以s为分割符，把x里的元素拼接为字符串

4.列表

1. 列表里的数据不需要具有相同的数据类型
2. 初始化：list = [1,2,3,4]
3. 遍历：for i in list i就是每个元素
4. 常用函数：
   - insert：insert
   - index：find
   - count：计数
   - append：push_back
   - pop(index)：默认末尾删除
   - remove：erase
   - reverse：反转
   - sort：sort
   - clear：clear
5. 遍历：

   # 遍历单个列表
   li = [1, 2, 3, 4]
   for i in range(len(li)):
       print(li[i])
   
   for x in li:
   	print(x) 
     
   # 同时遍历多个列表
   a = [1, 2, 3]
   b = ['a', 'b', 'c']
   for i, j in zip(a, b):
       print(i, j)
   

5.元组

1. 与列表类似，但是不能改变
2. 初始化：
   - tup1 = (‘Google’, ‘Runoob’, 1997, 2000)
   - tup2 = (1, 2, 3, 4, 5 )
   - tup3 = “a”, “b”, “c”, “d”
   - tup4 = (50,)
3. +：拼接
4. 应用：函数的返回值可以是元组，接受可以多变量

   def fn()
       return x,y,z
   
   a,b,c=fn()
   

6.字典

1. 初始化：d = {key1 : value1, key2 : value2, key3 : value3 }
2. 键唯一而且不可变（string、number可以，list不可以），值不唯一而且类型随意
3. 访问：dic[x]
4. 更新：dic[x]=8
5. 删除：del dic[x]
6. list不能嵌套进dict，但是dict可以嵌套进list
7. str(dict)：输出字典
8. 遍历：

   dic = {'a': 1, 'b': 2}
   for i,j in dic.items():
       print(i,j)
   

7.集合

1. 无序不重复元素序列
2. set = {1,2,3}或x = set(val)
3. 集合运算：
   - a-b：a中包含b不包含的元素
   - a|b：a或b包含的元素
   - a&b：a和b包含的元素
   - a^b：ab不同时包含的元素
4. 常用函数：
   - add/update
   - len
   - remove

8.索引

[头索引：尾索引：步长（1为正向遍历，-1为逆向遍历，2为每隔一个遍历）]

四、函数

1. 定义

   def fn():
       print()
   

2. 参数
   - 不可变类型传参相当于按值传递
   - 可变类型传参相当于引用传递

3. 不定长参数

   # 以元组储存：
   def fn(x,*tup):
   
   # 以字典储存：
   def fn(x,**dict):
   

五、类

一串代码足够讲明白python的类了

class Fu:
    name = "x"  # 类属性：类相关的特征（静态变量）
    __Myown = "only me"	# 私有类属性

    def __init__(self):  # 构造函数
        self.age = 1  # 实例属性
        print("构造函数")

    def __str__(self):  # 相当于toString
        return "toString"

    def fn(self):  # 实例方法 用self访问实例属性（第一个参数必须是self）
        print("实例方法 " + self.name + " fu")


class Zi(Fu):  # 单继承

    @staticmethod  # 静态方法
    def zi_fn():
        print("静态方法")

    @classmethod  # 类方法
    def zi_fn1(cls):
        print("类方法  用cls访问类属性，调用类方法" + cls.name)

    def fn(self):  # 重写父类函数
        print("实例方法 " + self.name + " zi")  # name为继承
        super(Zi, self).fn()  # 通过super调用父类被覆盖的方法


if __name__ == '__main__':
    son = Zi()
    fa = Fu()
    print("--------")
    print(fa.name + son.name + str(fa.age) + str(son.age))  # 继承的实例、类属性是相同的
    print("--------")
    Zi.zi_fn()  # 类名调用静态方法
    print("--------")
    Zi.zi_fn1()  # 类名调用类方法
    print("--------")
    son.fn()
    fa.fn()  # 重写过的函数
    print("--------")
    print(fa)  # 直接输出父类实例对象
    print("--------")
    son.temp = "外部设置,不推荐"  # 在类的外部设置实例变量  不推荐！！！
    print(son.temp)

六、异常

def test1():
    print("错误代码")

def test2():
    test1()

try:
    n = int(input())
    test2()  # 异常的传递性，函数里出现的一场会传递到主程序里来实现
    raise Exception("主动抛出异常")
except ValueError:
    print("输入错误")
except Exception as e:
    print("未知错误{}".format(e))
else:
    print("代码正确")
finally:
    print("无论是否成功都会执行")

七、模块

import test01
import test02 as b
from test01 import fn1
from test02 import fn2 as B
from test02 import *  # 但是不推荐

test01.fn1()
b.fn2()
fn1()
B()
fn3()

八、文件操作

fr = open("源文件地址")
fw = open("复制文件地址", "mode")

# 小文件操作：
text = fr.read()
fw.write(text)
# 大文件操作
while True:
    text = fr.readline()
    if not text:
        break
    fw.write(text)

fr.close()
fw.close()