python教学方法 python的入门教学

Python新手入门

• 前言
• 一、简单的输入输出

• 1.输入
• 2.输出
• 3.格式化数字

• 二、基础语法
• 三、变量类型

• 1、运算符
• 2.number
• 3.字符串
• 4.列表
• 5.元组
• 6.字典
• 7.集合
• 8.索引

• 四、函数
• 五、类
• 六、异常
• 七、模块
• 八、文件操作

前言

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

一、简单的输入输出

1.输入

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

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

2.输出

格式化输出用format()

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

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

1. 设置参数

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

1. 通过字典设置参数

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

1. 通过列表设置参数

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

1. 循环语句

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}')

1. 常用内置函数：

1.  - 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. 常用函数：

1.  - 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. 集合运算：

1.  - a-b：a中包含b不包含的元素
 - a|b：a或b包含的元素
 - a&b：a和b包含的元素
 - a^b：ab不同时包含的元素

4. 常用函数：

1.  - add/update
 - len
 - remove

8.索引

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

四、函数

1. 定义

def fn():
    print()

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

# 以元组储存：
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()