python基础大全
一、python基础语法
1.定义数据方法
# 定义数据就是起别名
# print("定义数据---------------------")
# num = 100
# s = 'good'
# b = True
# print(s)
# print(type(s))
2.输出
# print("输出------------------------")
# print(1)
# print(1, '123', 2)
# print(1 + 2)
# print('hello', end=',')
# print('world')
# print('good\nbye')
# print("我的年龄是%d岁" % num)
# print(f"我的年龄是{num}岁")
3.输入
# print("输入------------------------")
# p = input('输入密码:')
# print(f"你的密码{p}")
# 输入的全为字符串,运行时需要其他类型在进行转换
4.强制类型转换
# a = 10.4
# b = int(a) # 直接强制类型转换
# print(b)
# s1 = eval('100') # eval只能还原去掉引号后，能成为其他数据类型的
# print(type(s1))
5.算数运算符
# print(a / b) # 得浮点数
# print(a // b) # 取整
# print(a % b) # 取余
# a += b
# print(a)
# print(True and False)
# print(True or False)
# print(not True)
6.if语句
# num = 101
# if num == 100:
# print("是100")
# elif num < 100:
# print("小于100")
# else:
# print("大于100")
7.三目语句
# num = 100
# n = num-1 if num == 100 else num + 1
# print(n)
注意事项（代码规范、快捷键和注释）
# 单行注释
"""
多行注释 单引号也可
"""
"""
个人设置快捷键
# 注释快捷键 Ctrl + /
# 加# 对应 Shift +#
# 加换行快捷键 Ctrl + 回车
# 运行快捷键 Ctrl + R
# 代码格式快捷键 Ctrl + ?
对某一数据形成输出语法的快捷键 num.print+回车
"""
"""
代码规范
运算符与数据类型间有空格
# 应有一个空格
行最后加注释两空格
代码最后一行空行
python不用大小括号和分号,除了输出
依次用冒号，空格，不使用来代替
"""
二、循环语句
1.while循环
# num = 1
# while num < 100: #移除了大小括号，依次用冒号和空格表示
# num += 1
# print(num)
2.for循环
# s = '123456789'
# for i in s:
# print(i)
# for i in range(1,11,2):
# print(i)
3.break和continue
# 较其它语言，唯一不同多了for-else结构，else代表了未使用break推出的情况
# num = 100
# for i in range(101):
# if i == 101:
# break
# else:
# print(i)
Debug测试
# Debug调试
# print("打断点在序号代码中间，右键运行Debug，至少两个断点，右键Debug运行后，控制台进行下一步操作")
三、特殊的一些数据结构
1.公共方法
适用多种数据的方法+，*，in/not in, max/min
# 公共方法
# +，*，in/not in, max/min
# s1 = '1'
# s2 = '223456'
# print(s1 + s2)
# print(s1*10)
# print('1' in s1)
# print(max(s2)) # 对于字典来说比较key值大小
2.字符串
字符串格式
# 字符串是由单引号，双引号，三引号所包含定义的.三引号独特形式，所见即所得
# a = '12345667889z'
# s = "Hello Python"
# s1 = """ # 这里也可以换成三个三引号，只要是三个同类型引号即可
# good
# job
# """
# print(s1)
字符串遍历
# 字符串遍历
# s = "Hello Python"
# for i in s:
# print(i)
字符串判断
# 字符串判断
# isdigit(),isalpha(),isalnum(),islower(),isupper()
# a = '12345667889z'
# print(a.isdigit()) #至少一个字符，且全为数字
# b = 'ahdgkj'
# print(b.isalpha()) # 至少一个字符，且全为字母
# c = 'adg4156'
# print(c.isalnum()) # 判断所有字符都是字母或者数字
# d = ';;;;a'
# f = ';;;;A'
# print(d.islower()) # 判断字符串里所有字母都是小写
# print(f.isupper()) # 判断字符串里所有字母都是大写
字符串查找
# 字符串查找
# find(),index(),不同index查不到报错，find查不到但返回-1，但index基本通用
# a = '123456789078456'
# x = a.find('7', 0, len(a)) # 找‘7’找到后返回其索引
# y = a.rfind('7', 0, len(a)) # 从右边找
# z = a.rfind('a', 0, len(a))
# print(x)
# print(y)
# print(z) # 不存在则返回-1
# x1 = a.index('7', 0, len(a)) # 找‘7’找到后返回其索引
# y1 = a.rindex('7', 0, len(a)) # 从右边找
# # z1 = a.index('a', 0, len(a))
# print(x1)
# print(y1)
# # print(z1) # 不存在则报错
字符串替换
# 字符串替换
# replace（）
# a = '123456789123456789123456789'
# b = a.replace('1', 'a', 2) # 返回一个改变过的新字符串
# print(a) # a本身不变
# print(b)
# 字符串拆分与拼接
# split(),join(),拆分成列表，列表拼接成字符串
# a = 'Hello,auidfh,nadsjk'
# b = ['Hello', 'nihao', 'i love u']
# x = a.split(',') # 分割
# y = ','.join(b)
# print(x)
# print(y)
字符串切片
# 字符串切片操作
# s = '0123456'
# s1 = s[1:5]
# s2 = s[::-1]
# print(s1)
# print(s2)
字符串大小写转换
# 字符串大小写转换
# title(),capitalize(),upper(),lower()
# a = 'aa bb A'
# b = a.title() # 所有的单词首字母大写
# c = a.capitalize() # 只有第一个单词首字母大写
# e = a.upper() # 字符串字符全部大写
# f = a.lower() # 字符串字符全部小写
# print(b)
# print(c)
# print(e)
# print(f)
字符串左右空格操作
# 字符串左右空格操作
# rstrip(),lstrip(),strip()
# a = ' adff '
# c = a.rstrip() # 去除右边的空格
# d = a.lstrip() # 去除左边的空格
# e = a.strip() # 去除两边的空格
# print(c)
# print(d)
# print(e)
3.字典
字典定义
# 字典是用来存储键值对 key-value
# 空字典定义
# dict1 = {}
# dict2 = dict()
# print(dict1, type(dict1))
# 带数据字典定义
# dict = {'name': 'zhangshuo', 'age': 19, 19: '年龄', 'hobby': ['study', 'run', 'basketball']} # 以下均为对该字典进行操作
字典访问
# 字典访问
# print(dict['hobby'][1]) # 访问方式同列表，只不过第一个下脚表换成key值
# print(dict.get('hobby', '不存在返回的数据值')[1]) # 元组的访问方式是地址类的，所以字符串也可以加，但长度超出字符串会报错
字典修改
# 字典修改
# dict['job'] = 'student' # 有则修改，无则添加，系统波浪线提示可以加入表中
# print(dict['job'])
# print(dict[19.0]) # 整形和浮点型访问时相同
字典删除
# 字典删除pop，del，clear
# age = dict.pop('age') # 返回value
# del dict['name'] # 无返回值
# dict.clear() # 清空后显示空字典
# print(age)
字典遍历
# 字典遍历
# for遍历
# for key in dict:
# print(key, dict[key])
# keys(),values()，items()遍历
# result1 = dict.keys() # 得到dict_keys类型，存储key
# result2 = dict.values() # 得到dict_values类型，存储value
# result3 = dict.items() # 得到dict_items类型，存储键值对
# result = list(result3) # 三者好处就是可以使用list转换成列表类型,items视为二重数组
# print(type(result))
# print(result[1][0])
enumerate函数
# enumerate函数
# 将迭代中的元素所在下标和元素结合形成元组
# list = ['a', 'b', 'c']
# for i in list:
# print(list.index(i)) # 查看元素下脚表
# for j in enumerate(list):
# print(j)
4.列表
列表定义与访问
# 列表用于存放数据，数据称为元素
# 列表的创见和访问
# a = [1, 2, 3]
# print(a[0],a[1])
列表推导式
# 列表推导式
# 列表可以通过for语句的变形进行推导
# list1 = [i for i in range(5)]
# print(list1)
# list2 = [i for i in list1]
# print(list2)
# list3 = [i for i in range(5) if i % 2 ==0]
# print((list3))
# list4 = [[i, j] for i in range(5) for j in range(6)]
# print(list4)
列表添加元素
# 列表增加元素
# a = [1, 2, 3]
# a.insert(0, 4) # 在开始加入4
# a.append(5) # 在最后加入5
# a.extend('abc') # 将其中可迭代对象加入列表中
# print(a)
列表删除元素
# 列表删除元素
# a = [1, 3, 1, 3]
# a.remove(3) # 删除第一个3
# print(a)
# del a[0] # 删除下标为0的元素
# print(a)
# print(a.pop(0)) # 删除下标为0元素返回1
# a.clear() # 清空列表
列表修改元素
# 列表修改
# a = [1, 2, 3]
# a[0] = 2
# print(a)
列表升序降序排列
# 列表降序和升序
# 要求同类型
# a = ['a', 'c', 'b']
# a.sort() # 默认升序
# print(a)
# a.sort(reverse=True) # 降序
# print(a)
# a.reverse()
# print(a) # 逆序
列表切片
# 列表切片
# L = ['Google', 'Runoob', 'Taobao']
# print(L[::-1])
# print((L[1:2]))
# 查找元素及一些公共方法
# a = [1, 2, 3]
# print(a.index(3)) # 2
# print(a.count(3)) # 1
# print(len(a)) # 3
# if 2 in a:
# print('hahaha')
注意事项
# 注意事项
# 列表中可以有字典，但是访问字典不能用下角标而是key
# list = [dict, 'good']
# print(list[0]['name'])
5.数组
python中提供了列表操作代替了一般数组操作，但是列表对于每个其中每个元素都提供了指针，数据量大的时候占用空间较多。虽然python也有自带数组，但只有一维的。解决这类方法是python提供的numpy包。
numpy中数组讲解链接
5.元组
元组定义与访问
# 元组就是不能修改的列表，使用了（），除了修改的，其他方法大多都能用
# myTuple = ("Scrat", 18, 1.75)
# print(myTuple[0])
6.集合
集合定义
# 集合set
# 集合无序，不支持下角标操作，其内容必须为不可变类型，有相同的话，去重
# 集合定义
# my_set = {'1', 1, 'good', (1, 2)}
集合访问
# 集合访问,公共方法或遍历
# print('1' in my_set)
集合添加
# 集合添加
# my_set.add('100')
集合删除
# 集合随机删除
# my_set.pop()
# 集合指定删除
# my_set.remove((1, 2))
集合清空
# 集合清空数据
# my_set.clear()
# print(my_set)
7.数据结构间的相互转化
列表，元组，集合相互转化
# 可以将列表作为中转站.因为三者可以相互转换，所以只需考虑字符串和列表和字典两两转换即可
# 列表，元组，集合相互转换,
# my_set = {'1', 2, 6}
# my_list = list(my_set)
# print(my_list)
# my_tuple = tuple(my_list)
# print(my_tuple)
# my_set1 = set(my_list)
# print(my_set1)
列表转化为字符串
# 列表转换成字符串，join函数要求列表元素全是字符串，或者遍历+强制转化+拼接,或者str（）后进行字符串
# my_list = ['1', '2', '3']
# print(''.join(my_list)) # 结果123
# print(str(my_list)) # 转化为"['1', '2', '3']"
列表转化为字典
# 两个列表转化为字典，遍历赋值
# list_1 = ['a', 'b', 'c']
# list_2 = [1, 2, 3]
# dict_1 = {}
# for i in range(len(list_1)):
# dict_1[list_1[i]] = list_2[i]
# print(type(dict_1))
# print(dict_1)
字符串转化列表
# 字符串转化为所有类型，格式符合数据结构直接eval()函数。
# s1 = '[1, 2, 3]'
# list() 直接转化将导致每个字符都成为一个元素，不可取
# print(list(s1))
# print(eval(s1)) # 结果[1,2,3]
# 字符串分割形成列表
# s2 = 'good job'
# print(s2.split(' ', -1)) # -1表示无限次，分割后形成列表
# print(s2)
字符串转化为字典
# 字符串转化为字典,loads函数，传输数据中常用
# import json
# str_1 = '{"name":"xiaoming","age":18}'
# dict_1 = json.loads(str_1)
# print(type(dict_1))
# print(dict_1)
字典转化为字符串
# 字典转化为字符串,str()后字符串操作或者遍历+强制转化+拼接
# dict_1 = {"name":"xiaoming","age":18}
# print(str(dict_1)+'1')
字典转化为列表
# 字典转化为列表，遍历操作。list()转化只保留key值，不可取。
# dict_1 = {"name":"xiaoming","age":18}
# my_list = []
# for key, value in dict_1.items():
# my_list.append(key)
# my_list.append(value)
# print(my_list)
四、函数
1.全局变量
# 全局变量
# num = 100 # 在函数外声明的变量
# def fun1():
# global num # 函数内修改全局变量需要使用global声明下
# num = 100
# print(num)
1.函数定义
# 函数
# 函数带参定义
# def fun(a, b):
# return a + b
# print(fun(1, 2))
2.函数传参
# 函数传参两种形式
# def f(a, b, c, d):
# print(a, b, c, d)
# 位置传参
# f(1, 2, 3, 4)
# 赋值传参
# f(a=1, b=2, c=3, d=4) # 形参复制无需加空格
# 混合传参
# f(1, 2, d=3, c=4) # 要求,赋值传参要在位置传参后，位置传参对应，赋值传参可以不对应
3.函数形参形式
# 函数形式形参形式表达形式
#位置参数
# python不需要指名函数类型，很大一部分就是这一种参数原因。所有参数（列表，元组，字典等同样）都遵循位置一一对应。
# a = [1, 2, 3]
# b = 2
# dict1 = {'name': 'zhangshuo', 'age': 19, 19: '年龄', 'hobby': ['study', 'run', 'basketball']}
# def Lie1(a1, dict2, b1):
# print(a1[0])
# print(b1)
# print(dict2.get('name', [0]))
# Lie1(a, dict1, b)
# 缺省参数
# 缺省参数，缺省参数在参数最后。不赋值时，例f(1,2)，使用默认值c = 10。赋值时覆盖例f(1,2,3),c = 3
# def f(a, b, c=10):
其它一些特殊参数：（没搞懂前，尽量少用）
# 可变参数
# Python函数提供了可变参数，来方便进行参数个数未知时的调用。可变参数将以tuple形式传递。Python中只是一个标识符，表示将以tuple形式传递，星号本身有”全部的”意思。
# def getsum(*num):
# sum = 0
# for n in num:
# sum += n
# return sum
# list = [2, 3, 4]
# print(getsum(1, 2, 3))
# print(getsum(*list))
# 结果：6 9
# 关键字参数
# Python的可变参数以tuple形式传递，而关键字参数则是以dict形式传递。 即可变参数传递的是参数值，关键字参数传递的是参数名:参数值键值对。
# def personinfo(name, age, **kw):
# print('name:', name, 'age:', age, 'ps:', kw)
# personinfo('Steve', 22)
# personinfo('Lily', 23, city = 'Shanghai')
# personinfo('Leo', 23, gender = 'male',city = 'Shanghai')
# 结果：
# name: Steve age: 22 ps: {}
# name: Lily age: 23 ps: {'city': 'Shanghai'}
# name: Leo age: 23 ps: {'gender': 'male', 'city': 'Shanghai'}
# 命名关键字参数
# Python的命名关键字参数对传入的关键字参数做了进一步的限制。格式：在关键字参数前增加一个”*”。
# def personinfo(name, age, *, gender, city): #只能传递gender和city参数
# print(name, age, gender, city)
# personinfo('Steve', 22, gender = 'male', city = 'shanghai')
# 结果
# Steve 22 male shanghai
# 各种参数之间组合
# 顺序：基本参数、默认参数、可变参数、命名关键字参数和关键字参数。
# def function(a, b, c=0, *, d, **kw):
# print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
# 可读性是代码的一个很重要的要求，所以尽量避免使用多种参数的组合。
4.匿名函数lambda
# 匿名函数lambda
# 一些位置需要对参数进行简单的函数运算，就可以使用匿名函数，而不必再去写与调用其他函数
# 匿名函数表达简单，占位时可以看到结构，多个参数，一个表达式
# 匿名函数因为匿名，所以在函数外，必须命名才能使用
# def f(a, b, f1):
# n = f1(a, b)
# print(n)
# f(1, 2, lambda a, b: a + b)
# x = lambda a: a*a
# print(x(2))
# 字典比较中就可以使用匿名函数，要求字典类型相同.
# 字符串长度比较中也可以使用匿名函数
# list = [
# {'name': 'b', 'age': '10'}, {'name': 'a', 'age': '8'} # 一些分隔符与前面不空格，与后面空格
# ]
# list.sort(key=lambda x: x['name']) # 括号内赋值无需加空格
# print(list)
# list1 = ['good', 'ok', 'important']
# list1.sort(key=lambda x: len(x))
# print(list1)
5.注意事项
# 返回值注意事项
# def fun2():
# a = 1
# b = 2
# return a, b # 返回多个值时，类型为元组，元组为不可更改列表，故访问方式相同
# print(type(fun2()))
# print(fun2()[0],fun2()[1])
五、类与对象
1.类
类的定义与访问
# 对属性和方法的抽象，类的封装
# 定义驼峰命名
# class Dog(object):
# name = 'doudou' # 属性
# def go():
# print('go')
# def play(self): # 类中函数称为方法
# print('小狗是',self.name)
# print(f"{self.name}在拆家.....") # 调用自身属性
# print(Dog.name)
# Dog.go()
# print(Dog.play(Dog)) # 调用类中有self的方法，必须指明参数self=类名。
2.对象
对象的定义与访问
# 对象
# 类的实例化，对现实生活的抽象
# 实现
# dog = Dog()
# print(dog.name)
# dog.play() # 对象调用，无需指明self
# dog.name = 'dahuang'
# print(dog.name) # 对象可以在外部更改自身公共属性
3.魔术方法
# class魔术方法__init__(),__str__(),__del__()
# class Dog(object):
# def __init__(self, name, color): # 重写init方法，对象创建时调用，且规定了*形参*，形参会成为属性添加进去,但本类中其他方法不能调用
# print("我是__init__方法，我被调用了")
# self.name = name # 创建对象时，给对象添加的新属性
# self.color = color
# print('__姓名和颜色形参作为属性添加进来啦')
#
# def __str__(self): # 重写str方法，使用print（对象）和str（对象）时，会使用其方法的返回值
# print("我是__str__方法，我被调用了")
# return "print(对象)和str(对象)的返回值"
#
# def __del__(self): # 重写del方法，析构函数。del 变量，消除一个变量的一个引用。当一个变量的引用为零时，调用其将变量释放
# print("我是__del__方法，我被调用了")
#
#
# dog = Dog('狗剩', '黄色')
# print(dog.name)
# print(dog.color)
# print(dog)
# del dog # 即使不加这一句，也会在程序执行完毕后释放所有资源
六、继承与多态
1.继承
# 继承
# 继承分为基类和派生类，或者子类和父类，子类继承父类后，拥有其方法和公共属性，且可重写，添加
#
#
# class Animal(object):
# def __init__(self, name):
# self.name = name
#
# def play(self):
# print("在线玩耍了啊")
#
#
# class Pet(object):
# pass # pass代表空代码
#
#
# class Dog(Animal, Pet): # 多继承，继承多个父类，属性方法多了
# age = 18 # 共有变量，实例化后，对象中变为实例属性，可以继承
# _leg = '保护' # 标识符前加单个下划线成为保护变量，同共有变量不同的是不能通过import包导出其余都可以
# __leg = '私有' # 标识符前加两个下划线成为私有权限，不能被继承，不能被实例，只允许类本身内部出现，外部类也无法调用。可以通过get函数提取
#
# def get__lge(self):
# return self.__leg
#
# def __init__(self, name, color):
# Animal.__init__(self, name) # 与其他语言不同，python不显式调用父类init方法，就不会自己调用
# # self.name = name # 不用调用父类,自己重写写也完全可以
# self.color = color
#
# def play(self): # 重写play方法
# print('离线玩耍')
#
# def in_play(self):
# Animal.play(self) # 调用父类的方法，需手动添加self
# # print(self.__leg) # 私有变量只能在自己类中方法被调用
# # super().play()
# # super(Dog, self).play() # 名称是自己的
# 一些特殊方法需要提前声明
# @classmethod # 类方法，cls是类本身，对象调用是也是类本身的
# def getClassAge(cls):
# return cls.age
#
# @staticmethod # 静态方法，不能有形参,可被类与对象访问
# def getStatic():
# print('good')
#
#
# class ShortDog(Dog): # 多重继承，单继承链上全部可以使用
# pass
#
#
# dog = Dog('go', 'yellow')
# print(dog.name)
# dog.age = 20
# print(dog.age)
# print(dog.getClassAge())
# print(dog.color)
# dog.play()
# dog.in_play()
# print(dog.get__lge())
# # print(Dog(' ', ' ').__leg) # 报错私有变量，即使是类自身也不能在外部直接调用
2.多态
# 多态
# class Father(object):
# def play(self):
# print("like")
#
#
# class Son(Father):
# def play(self):
# print("love")
#
#
# def duoTai_class(cobj): # 类任何标识符都可作为形参
# cobj.play(cobj) # 当类调用类方法时，必须将参数完整填完，包括self，填自身
# def duoTai_object(cobj): # 对象任何标识符都可作为形参
# cobj.play() # 当对象调用方法时，不填self，
#
# duoTai_class(Father)
# duoTai_class(Son)
#
# father = Son()
# duoTai_object(father)
七、异常
1.捕获异常
# 异常
# 异常，运行过程中错误提示，或错误。异常组成 '异常类型'：'具体描述信息'
# 嵌套时，异常传递波浪式向外传递，直到被截获
# 捕获单个异常
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except ZeroDivisionError:
# print('输入违法')
# print('结束')
# 捕获多个异常
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except (ZeroDivisionError, ValueError):
# print('输入违法')
# print('结束')
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except ZeroDivisionError:
# print('输入违法1')
# except ValueError:
# print('输入违法2')
# print('结束')
# 捕获所有异常
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except Exception as e: # Exception是常见异常的父类
# print('输入违法：')
# print(e)
# print('结束')
# 打印异常信息
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except ZeroDivisionError as e:
# print('输入违法：')
# print(e)
# print('结束')
2.完整捕获异常结构
# 完整异常结构
# num = 0
# try:
# num = 10/num
# print(f'结果：{num}')
# except ZeroDivisionError as e:
# print('输入违法：')
# print(e)
# else:
# print("未发生异常信息")
# finally:
# print("最后都会执行的")
3.自己定义异常类
# 自己定义异常类
# class PasswordLengthError(Exception):
# pass
#
# def getPassword():
# num = '123456'
# if (len(num) < 6):
# print("没错")
# else:
# raise PasswordLengthError('异常时，返回的__str__语句') # 自己定义的异常被需要被抛出
# try:
# getPassword()
# except PasswordLengthError as e:
# print(e)
# print("结束")
八、模块与包
模块与包需要涉及路径问题.路径如下：
P12.py
# 模块
# 模块，本质时以.py结尾的python的文件，逻辑上组织python代码，搜索顺序本列表——系统列表——报错
# 模块导入与调用
# import os # 一种方法，可以加逗号链接多个，但不符合最新规范，多个导入最好
# print(os.getcwd()) # 模块名.属性或方法（）
# print(os.sep)
# from os import sep # 第二种方法，导特定的属性或方法
# print(sep) # 直接访问
# from os import * # 第三种方法，导全部的属性或方法
# print(sep) # 直接访问
# import os as so # 第三种方法，起别名，原名不可再使用
# print(so.sep)
# from os import sep as p
# print(p)
# 模块中一些变量
# __all__变量，列表或元组,一有此变量则只能访问此变量的元素，元素对应了属性方法
# __name__ == '__main__', 可以理解成为在此条件下，之中的属性和方法成为了只能该包内调用，外包只能用else
# from P12_1 import *
# print(name)
# f()
# f1() # 报错
# 包
# 功能相近或者相似的模块放在一个目录里，并在目录里定义一个__init__文件（创建后系统自己定义），这个目录就是包
# 导入包中内容
# 方法一
import P12_2Package.P12_2 # 加小数点
print(P12_2Package.P12_2.name)
# 方法二
from P12_2Package.P12_2 import *
print(name)
# 方法三
from P12_2Package import * # 导入的是包中__init__的内容
print(name)
p12_1.py
def start(): # __name__ == '__main__', 可以理解成为在此条件下，之中的属性和方法成为了只能该包内调用，外包只能用else
if __name__ == '__main__': # 快捷键main加回车
print('运行__name__了：', __name__)
else:
print('运行了其他代码')
__all__ = ['name', 'f', 'start'] # __all__变量，列表或元组,一有此变量则只能访问此变量的元素，元素对应了属性方法
name = 'good'
def f():
print('better')
def f1():
print('best')
start() # 在外包中一旦被导入，就会运行
init.py
name = 'init'
P12_2.py
name = 'P12_2'
def f():
print('go out')
九、文件
文件需要涉及路径问题.路径如下：
P13.py
# 文件
# 可永久的保存数据
# 打开文件
# 1,文本打开方式
# fr = open('P13_1.txt', 'r', encoding='utf-8') # 只读方式打开，指针在最前准备读,指针读完后，保存在既定位置。所有读法使用同一指针
# fw = open('P13_1.txt', 'w', encoding='utf-8') # 只写方式打开，先**清空**再覆盖，写读同时，啥也读不到
# fa = open('P13_1.txt', 'a', encoding='utf-8') # 追加方式打开，指针在在最后添加
# 2,二进制打开方式，加b，不能指定编码，因为二进制没有编码，模式rb，wb，ab,同上
# frb = open('P13_1.txt', 'rb')
# fwb = open('P13_1.txt', 'wb')
# fab = open('P13_1.txt', 'ab')
# 3，特殊打开方式,加+，全部变成读写功能，模式r+,w+，科协,a+,rb+,wb+,ab+
# fr_1 = open('P13_1.txt', 'r+', encoding='utf-8')
# fw_1 = open('P13_1.txt', 'w+', encoding='utf-8')
# fa_1 = open('P13_1.txt', 'a+', encoding='utf-8')
# 文件读写
# 1,文本读写
# for i in range(10):
# fw.write('董雪爱我')
# fa.write('我也爱董雪')
# buf = fr.read()
# print(buf)
# while True:
# buf1 = fr.readline()
# if (buf1):
# print(buf1, end ='')
# else:
# break
# buf2 = fr.readlines()
# print(buf2)
# 2,二进制读写
# fab.write('good'.encode()) # encode将字符串转化为二进制
# print(frb.read().decode()) # decode将二进制转化为字符串
# 三,特殊读写
# fr_1.write('good')
# print(fr_1.read())
# 文件关闭
# fr_1.close()
# 文件指针操作
import os
# fr_1 = open('P13_1.txt', 'rb+') # python3中必须使用二进制才能实现1，2选项
# print(fr_1.tell())
# fr_1.seek(10, 1) # 第一个偏移量，第二个是选项0：表示文件的开头,1：表示文件的相对当前位置,2：表示文件的结尾，正往后，负往前
# print(fr_1.tell())
# 文件和目录的操作
# import os # 对文件和文件夹的操作选需要os模块。不是绝对路径就判定相对路径
# 创建目录
# os.mkdir('P13_2/dir')
# # 删除空目录
# os.rmdir('P13_2/dir')
# # 获取当前所在目录
# print(os.getcwd())
# # 修改当前目录
# os.chdir('P13_2')
# print(os.getcwd())
# os.chdir('../')
# print(os.getcwd())
# # 获得目录列表
# print(os.listdir("P12_2Package")) # 可指定路径不指定默认此文件所在目录
# 文件重命名
# os.rename('P13_1.txt', 'P13_3.txt') #必须要加后缀名
# os.rename('P13_3.txt', 'P13_1.txt') # 改回来
# 文件删除
# os.remove('P13_3.py') # 直接删除，回收站都找不到的那种
P13_1.py
good爱我董雪爱我董雪爱我董雪爱我董雪爱我董雪爱我董雪爱我董雪爱我董雪爱我董雪爱我我也爱董雪嘿嘿我也爱董雪我也爱董雪我也爱董雪goodgood
P13_2
仅仅一个文件夹
P13_3.py
空
十、总结
很久之前，大概好像是大一，似乎是通过《以Python为舟，了解编程什么什么的》这门学校开的课接触过python，当时老师python和其他的一块讲，python也没学好，其他的也没学好。但是之后因为要参加一些比赛，所以c、c艹，java还是掌握的不错的。现在马上要开始研究生生活了，要进行深度学习的研究，所以python不得不重新学一下。python的代表语言不愧是“人生苦短，我用python”，省略大小括号、变量自动识别等都让人十分省心，可以把心思更多的放在逻辑结构上。我用了三天把所有python基础全实现了一遍，因为我习惯把自己需要总结的放注释上，所以整理到博客上的时候，大部分还是在注释上，像继承和多态这一块一块就给放上去了，反正代码一看就清楚。整体还是比较细节的，有很多平常变成用不到的，像最后两章，我也给放上去了。我就一个要求，转载标明出处，好歹我也忙了三天，谢谢！
另外，一些语言基础可以在https://www.cjavapy.com/上学习。
3266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
