Python基础知识-1

注释的使用

#表示的是一个注释
print("hello world")

常见的数据类型

数字类型：

整数型int

print(10)

浮点型float

print(3.1415)

复数complex

print((-1)**0.5)

字符串类型

布尔型

列表型/数组型

['aa','bb']

字典类型

{'name':"lhh",'user':'秦始皇'}

元祖型

（1,2,3,552,3,4,5）

集合类型

{9,'hello',true,'good'}

查看数据类型

a = (-1)**0.5
b = 2**2
print(a,b)
print(type(a))

print(isinstance(c,str)) 
#Ture

不同进制数据的表示方式

a = 98 #十进制
b = 0b0101010101 #二进制
c = 0o23     #八进制
d = 0x1134   #十六进制

循环语句

import random
tempNum = int(input('请输入指定数字:'))
secret = random.randint(1, 10)
print(secret)
while tempNum != secret:
    temp = int(input("猜错啦！请重新输入："))
    if temp > secret:
        print("太大啦")7
    else:
        if temp < secret:
            print("太小啦")
    if temp == secret:

        print("恭喜你！猜对啦")
        break

import random
secret = random.randint(1, 3)

a = 2

if secret == 1:
    print('secret为1')
elif secret == 2:
    print('secret为2')
else:
    print('secret为3')

或且非

or and not

Pass关键字的使用

eg:可用来占位;pass 是一种空操作，解释器执行到它的时候，除了检查语法是否合法，什么也不做就直接跳过。

import random
secret = random.randint(1, 3)

a = int(input("请输入数字："))

if a == 1:
    pass
    print('secret为1')

假设法求质数

for i in range(2, 101):
    flag = True
    for j in range(2, int(i ** 0.5)):
        if i % j == 0:
            flag = False
            break
    if flag is True:
        print(i, '是质数')

字符串

py = 'sjhjsdhahsj"sadhajsdajkshj"'
# print(py[2:])
# 字符串切片语法 m[start:end:step]
# step指的是步长，每隔step-1个截取一次
print(py[2:15:3])

获取字符串长度

x = 'sjasjdhajdhaskhdaj'
print(len(x))

查找字符串方法

find/rfind/index/findex

x = 'sjasjdhajdhaskhdaj'
print(x.find('j'))
print(x.index('j'))
print(x.rindex('j'))
print(x.rfind('j'))

in 和 not in

x = input("请输入内容：")
strContent = 'aa112277oopsksalsd'
if x not in strContent:
    print("输入正确")

format 字符串拼接

a = '我是{name}'.format(name='李嘉诚')
# 什么都不写，会读取后面的内容，一一对应
b = '这里是{}{}{}'.format(1, 2, 3)

# 数字 可以根据索引来填充
c = '这里是{2}{2}{2}'.format('l', 'u', 'c', 'k', 'y')

# 混合使用数字和变量
d = '这里是{name}{1}{3}'.format('中国', '我', 1, '上海', name='李')

info = {'name': 'handsome', 'age': '10'}
h = '大家好，我是{name}'.format(**info)

字符串常用方法

列表(数组)常用方法

浅拷贝

import copy
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = a.copy()
c = copy.copy(b)
print(c)

python常用系统模块

函数

def tellHandler():
    a = int(input("请输入值："))
    if (a > 10):
        print("函数执行成功啦！")
    else:
        print("函数暂时未执行")


tellHandler()

函数的缺省函数

函数的可变参数

*arg表示可变位置参数

**arg表示可变的关键字参数

def callHandler(name, *bb, mul=10, kk=20, **arg):

    ui = bb
    print(name, mul, kk, '列表：', ui[1], arg['q'])

装饰器

import time


def caltime(fn):
    def inner(x):
        start = time.time()
        s = fn(x)
        end = time.time()
        print("代码耗时", end-start, x)
        return s
    return inner


@caltime
def demo(n):
    x = 0
    for i in range(1, n):
        x += i
    return x


def calClk(fn):
    def inner(x):
        start = time.time()
        # m = fn(x)
        end = time.time()
        print('时间', end-start,)
        return 10
    return inner


@calClk
def dearFn(n):
    x = 0
    for i in range(1, n):
        x += i
    print("dearFn{}值".format(x))
    return 'dear'


kk = dearFn(100)
print(kk)


def add(fn):
    def inner(game, name, time):
        if (time > 60):
            print("时间到了不能玩了")
        else:
            fn(game, name, time)
    return inner


@add
def playHandler(game, name, time):
    print('{game}在玩{name}用时{time}'.format(game=game, name=name, time=time))


playHandler('王者', '王宝强', 60)
# 装饰器的返回值在于装饰器函数内的返回值，如果原函数在装饰器内部函数中调用，原函数的返回值将在内置的函数中访问到

装饰器可变参数

def add(fn):
    def inner(game, name, *args, **kwargs):
        clock = kwargs['clock']
        if (clock > 60):
            print("时间到了不能玩了", clock)
        else:
            fn(game, name, clock)
    return inner


@add
def playHandler(game, name, time):
    print('{game}在玩{name}用时{time}'.format(game=game, name=name, time=time))


# playHandler('王者', '王宝强', clock=60)
# 装饰器的返回值在于装饰器函数内的返回值，如果原函数在装饰器内部函数中调用，原函数的返回值将在内置的函数中访问到


def callHandler(name, *bb, mul=10, kk=20, **arg):
    ui = bb
    print(name, mul, kk, '列表：', ui[1], arg['q'])


callHandler('kk', 1, 2, 3, 4, 5, q='bb')

模块

概念：一个py文件就可以理解为一个模块

python常见的系统模块

OS模块
sys模块
math模块
random模块
datetime模块
time模块
calendar模块
hashlib模块
hmac模块
copy模块
uuid模块

PIP命令

pip freeze

pip list

镜像

pip install <package_name> -i 从指定的地址下载包

name

直接运行python程序时，__name__的值为“__main__”

而在其它程序中导入.py文件运行时，__name__的值为文件名，即模块名

Python类

class person:
    
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def clickHandler(self):
        print("点击成功", self.name)
        
A = person('小红', 26, 170)
A.clickHandler()

__开始的是私有变量

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__moneny = 10000000000

    def moreMoney(self):
        print(self.__moneny)

    def __getMoney():
        print("千万富翁")


A = Person('小李', 27)
A.moreMoney()

python的魔术方法

slots

class person:
    __slots__ = ('name', 'age', 'ui', 'height', 'test')

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
        self.ui = age

    def clickHandler(self):
        print("点击成功", self.name)


A = person('小红', 26, 170)

A.test = 'test'
print(A.ui)

init

#在创建对象时会自动调用这个方法
class person:
    __slots__ = ('name', 'age', 'ui', 'height', 'test')

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
        self.ui = age
        print("自动调用了吗")

    def clickHandler(self):
        print("点击成功", self.name)

____del

class person:
    __slots__ = ('name', 'age', 'ui', 'height', 'test')

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
        self.ui = age
        print("自动调用了吗")
# 当对象销毁时，会调用这个方法

    def __del__(self):
        print("销毁时调用了")

    def clickHandler(self):
        print("点击成功", self.name)

str

repr

call

eq

setItem

可以在类中重写，如果不重写，比较的将是内存地址。

is

is身份运算符，可以判断两个对象是否是同一个对象

==会调用对象的__eq__方法，获取这个方法的比较结果

class person:
    __slots__ = ('name', 'age', 'ui', 'height', 'test')

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
        self.ui = age
        print("自动调用了吗")
# 当对象销毁时，会调用这个方法

    def __del__(self):
        print("销毁时调用了")

    def clickHandler(self):
        print("点击成功", self.name)


A = person("a", 'A', 12)
B = person("a", 'A', 12)


C = [1, 2, 3]
D = [1, 2, 3]
print(A is B, C == D)

类的静态方法

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__moneny = 10000000000

    def moreMoney(self):
        print(self.__moneny)

    def __getMoney():
        print("千万富翁")

    @staticmethod
    def clickHandler():
        print("静态方法打印成功")


Person.clickHandler()

类的继承

#传入object指继承自object
#python3以后，默认继承自object
class 
class Animal(object):
    def __init__(self, name):
        self.name = name
        print(self.name)

    def sleep(self):
        print("动物都会睡觉")


class Person(Animal):
    def thinkAbout(self):
        print("人类会思考")


A = Person('name')
A.sleep()

经典类和老式类

1、新式类：继承自Object的类，我们称之为新式类
2、经典类：不继承自Object的类

# 新式类和老式类
class Student(object):
    pass


class Dog:
    pass

isinstance

判断一个对象是否是由指定的类实例化出来的

#判断一个对象是否是由指定的类实例化出来的
class Student(object):
    pass


class Dog:
    pass


A = Student()
print(isinstance(A, Student))

子类重写父类方法

多态

# 多态是基于继承，通过子类重写父类的方法

# 达到不同的子类对象调用相同的父类方法，得到不同的结果。

# 提高代码的灵活度

# 子类重写父类方法
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self):
        print("好好学习，天天向上")

    def schoolHandler(self):
        print('{name}去上学啦'.format(name=self.name))


class Student(Person):
    def __init__(self, name, age, school):
        # 1.父类名.方法名(self,参数列表)
        # Person.__init__(self, name, age)
        self.school = school
        # 2.使用super直接调用父类的方法
        super().__init__(name, age)

    def schoolHandler(self):
        print("重写父类方法")
        return super().schoolHandler()


P = Student('小杨', 22, '北大')
P.schoolHandler()

多态的使用

class Dog(object):
    def work(self):
        print('狗正在工作')


class PoliceDog(Dog):
    pass


class Person(object):
    def __init__(self, name):
        self.name = name


newP = Person(Dog)

newP.name.work('name')

文件操作

场景：python代码操作，写入数据，只存在于内存当中。永久保存数据可以选择存在系统硬盘的文件当中。

open

参数介绍：

1. ​ file:用来指定打开的文件(不是文件的名字，而是文件的路径)
2. ​ mode:打开文件时的模式，默认 r 表示只读 ,w是写入模式，打开文件以后，只能写入，不能读取。如果文件存在，会覆盖文件。 rb 读取写入的结果是二进制 ，r+：可读写 w+:可读写
3. ​ encoding :打开文件时的编码方式

读取文件内容

print(open('./1.txt', encoding='utf8').read())

写入文件内容

普通方式写入

file = open('./1.txt', 'w', encoding='utf8')
file.write('我是霸道总裁',)

二进制方式写入（操作非文本文件）

file = open('./1.txt', 'wb')
file.write('我是霸道总裁啦'.encode('utf8'))

路径

1、绝对路径：从电脑盘符开始的路径

2、相对路径：

file.read()

讲所有文件都读取出来

file.readline()

只读取一行数据

file.readlines()

读取所有行的数据，保存在一个列表里

文件的拷贝

新文件名拼接

rpartition

os.path.splitext

import os

file_name = input('请输入一个文件路径：')

if os.path.isfile(file_name):
    old_file = open(file_name, encoding='utf8')
    names = file_name.rpartition('.')
    new_file_name = names[0]+'_new'+names[2]
    print(names, new_file_name)

else:
    print('您输入的文件不存在')

将数据写入内存

StringIO

from io import StringIO

s_io = StringIO()

print('GOOD', file=s_io)
print(s_io.getvalue())

BytesIO

from io import BytesIO

b_io = BytesIO()

b_io.write('你好'.encode('utf8'))

print(b_io.getvalue().decode('utf8'))

标准输入

stdout

会将用户输入的信息打印到指定的文件内

import sys
# sys.stdin  接收用户的输入，说白了就是读取键盘里输入的数据
# sys.stdout 标准输出
# sys.stderr 错误输出
sys.stdout = open('stdout.txt', 'w', encoding='utf8')
print("杨静杨智")

stderr

import sys
# sys.stdin  接收用户的输入，说白了就是读取键盘里输入的数据
# sys.stdout 标准输出
# sys.stderr 错误输出
sys.stdout = open('stdout.txt', 'w', encoding='utf8')
print("杨静杨智")
sys.stderr = open('stderr', 'w', encoding='utf8')
print(1/0)

Json字符串

对象转json

import json
# json里将数据持久有两个方法
# dumps:将数据转换成json字符串，不会将数据爆粗难道文件里。
# dump:将数据转换成json字符串的同时写入到指定文件

names = ['qqes', 'ddfd']

file = open('names.txt', 'w', encoding='utf8')

json.dump(names, file)

file.close()

json转对象

import json

# json里将数据持久有两个方法
# loads:将json字符串转换成数据，不会将数据保存在文件里。
# load:将数据转换成json字符串的同时写入到指定文件
x = '{"name":"zhangsan"}'
p = json.loads(x)
print(p['name'])

数据转二进制

1. 序列化 dumps：将python数据转换成为二进制
2. dump:将python数据转换成为二进制，同时保存到指定的文件
3. 反序列化 loads:将二进制加载成为python数据
4. load:读取文件，并将文件的内容加载成为二进制

# json:将python里的数据（str/list/tuple/dict/int/float/bool/None）等转换成对应的json
# pickle:将python里的任意的对象转换成为二进制
import pickle

names = ["战三", "lisi1"]

b_names = pickle.dumps(names)
print(b_names)


# 序列化   dumps：将python数据转换成为二进制
#         dump:将python数据转换成为二进制，同时保存到指定的文件
# 反序列化   loads:将二进制加载成为python数据
#            load:读取文件，并将文件的内容加载成为二进制

pickle和json的区别

pickle用来讲数据原封不动的转换成为二进制

但是这个二进制只能在python里识别

json只能保存一部分信息，作用是用来在不同的平台里传递数据。

json里存储的数据都是基本的数据类型。

try … except

# try ... except 语句用来处理程序运行过程中的异常

try:
    print(1/0)
    file = open('names.txt')
    print(file.read())
    file.close()

except (FileNotFoundError, ZeroDivisionError) as e:
    # 处理指定类型的异常
    print("出错了", e)

finally

def demo(a, b):
    try:
        return a
    finally:
        return b


print(demo(1, 2))
# 如果函数里有finally,finally里的返回值会覆盖之前的返回值

with

try:
    with open('name.txt', 'r', encoding='utf8') as file:
        file.read()  # 不需要在手动的关闭文件
except FileExistsError:
    print("文件未找到")
# with我们称之为上下文管理器，很多需要手动关闭的连接
# 比如说文件连接，socket连接，数据库的连接，都能使用with自动关闭连接
# with关键字后面对象，需要实现__enter__和__exit__魔法方法

自定义异常

# 自定义异常
class LengthError(Exception):
    def __intt__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return "长度必须要在{}至{}之间".format(self.x, self.y)


password = input("请输入您的密码：")
m = 6
n = 12
if m <= len(password) <= n:
    print("密码正确")
else:
    raise LengthError

高级装饰器

def handleAction(a):
    print(a)

    def inner(fn):
        def hannder(name, age):
            print(name, age)
        return hannder
    return inner


@handleAction('aa')
def playGAME():
    print("玩游戏", )


playGAME('aa', 'bb')

可迭代对象

# 可迭代对象：list/tuple/dict/set/str/range/filter/map
# 只要重写了__iter__方法就是一个可迭代对象
from collections.abc import Iterable


class Demo(object):
    def __init__(self, x):
        self.x = x

    def __iter__(self):
        pass


d = Demo(100)
print(isinstance(d, Iterable))

# 可迭代对象：list/tuple/dict/set/str/range/filter/map
# 只要重写了__iter__方法就是一个可迭代对象
from collections.abc import Iterable


class Foo(object):
    def __next__(self):
        return 1


class Demo(object):
    def __init__(self, x):
        self.x = x

    def __iter__(self):
        f = Foo()
        return f
        pass


d = Demo(100)
print(isinstance(d, Iterable))
# for in循环的本质就是调用可迭代对象的__iner__方法，获取到这个方法的返回值
# 这个返回值需要的是一个对象，然后再调用这个对象的__next__方法