python

数据类型

int : 整型

float

bool : True False . C89中C语言是没有bool类型 C99中有bool类型

#define true 1 #define false 0

str: 字符串.

list: 列表 容器,里面存放各种类型的数据

tuple: 元组 容器

dict: 字典

标识符

程序员自定义的符号.

规则:

1.由数字,字母,下划线组成,并且数字不能开头

2.不能和关键字重合

3.见名知意

4.驼峰命名法

                     大驼峰:每一个单词的首字母大写 eg:类名

                       小驼峰:第一个单词首字母小写其他的大写

                           eg:windows编程中 函数名, 变量名

5.通过下划线链接

eg: Linux编程当中. 统一使用下划线链接

关键字

语言的作者赋予一些词语特殊的含义.

python当中的关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

运算符

/ : 除法 9 /2 = 4.5

//: 整除 9//2 = 4

: 幂运算 210 = 2 ^ 10 = 1024

python中没有 ++ -- 这种赋作用的运算符.

python支持同时赋值 a,b=10,20;

交换值

c语言中：

int c=a;

a=b;

b=c;

/

若对空间有限制，不能申请变量

用两个数的和

a=a+b;

b=a-b;

a=a-b;

/

若数值过大

异或：相同为0，异或与顺序无关

a=a^b; //a=a^b

b=a^b;// b=a^b^b =a^0=a

a=a^b; //a=a^a

/

python中：

a,b=10,20;

a,b=b,a;

逻辑运算符

and : 与运算符: 两个真且为真

or : 或运算符: 有真就为真

not : 非运算符: 真假互换

input函数

特点: 无论输入任何类型的数据,最终在程序中都是以 字符串 形式显示的.

eg：

type函数

功能：查看变量的类型强制类型转换格式: 想要转换的类型(变量)

            强制类型转换格式: 想要转换的类型(变量)

python逻辑语句

判断语句

概念:

判断某件事情是否成立,根据是否成立,执行相应的语句

格式1:

if 判断条件:

(Tab) 条件成立执行的语句

if else 格式

if condition1:

code1 // condition1成立执行代码

else:

code2 // condition1不成立执行的代码

########################################################

python 当中的随机数:

import random # 随机数模块

# 产生随机数

computer = random.randint(0, 2)

while condition:

code

i = 1

while i < 101:

print("第 %d 次 .妈妈,我错啦. 我再也不敢了" )

i += 1

for 循环

for格式：

for 临时变量 in 字符串 列表 字典等可迭代对象：

code

可迭代对象：拥有迭代器的对象，就称为可迭代对象

迭代器：通过++找到对象的下一个位置；用* 取出迭代器里面的值

用途：遍历：将不同的类型按照相同的格式进行遍历

range函数

用法：range（起始位置，终止位置，步长） 步长：每次加多少

特点：前面是闭区间后面是开区间

字符串string

引号之间的内容就是所谓的字符串

单引号和双引号之间的内容就是字符串

三引号之间的内容就是多行字符串 //分行

访问

数组支持下标访问：

从左到右，下标从0开始；

从右到左，下标从-1开始

切片

格式： var变量 [ 初始位置：终止位置：步长 ]

初始位置：默认字符串的开始位置

终止位置:字符串的结尾

步长：默认为1

字符串处理

查询统计家族

功能：在原字符串查找子字符串的位置

函数： find rfind index rindex

find函数：

功能：在原字符串查找子字符串的位置

返回值：

成功：子字符串的初始下标

失败：-1

rfind函数

功能：从右到左查找子字符串在原字符串的位置

返回值：

成功：子字符串的初始下标

失败：-1

index函数

功能：在原字符串中查找子字符串的位置

返回值：

成功：子字符串的初始下标

失败：报错

rindex函数

功能：从右到左查找子字符串在原字符串的位置

返回值：

成功：子字符串的初始下标

失败：报错

分割家族

split函数

功能：按照指定的字符对字符串进行分割

splitlines函数

功能： 按行分割

返回值：根据行分割好的字符串列表

变换家族

功能：对字符串中的字母进行大小写变换

upper函数

功能：将字符串的内容全部转换成大写

返回值：转换成功后的字符串

lower函数

功能：将字符串的内容全部转换成小写

返回值：转换成功后的字符串

判断家族

功能：对字符串进行判断

startswitch函数

功能：对字符串是否以xxxxx开头

返回值：

成功：True

失败：False

endswitch函数

功能：对字符串是否以xxxxx结尾

返回值：

成功：True

失败：False

is族判断

isalpha ：判断是否全是由字母组成

isdigit： 判断是否全是由数字组成

isalnum：判断是否全是由字母或数字组成

isspace： 判断是否全是由空格组成

对齐家族

center

功能：按照指定的长度对字符串进行居中，默认填充的字符是空格

ljust

功能：按照指定的长度对字符串进行左对齐，默认填充的字符是空格

rjust

功能：按照指定的长度对字符串进行右对齐，默认填充的字符是空格

整理家族

功能：去除字符串左右两端指定的字符

strip函数

功能：去除字符串两端指定的内容

lstrip函数

功能：去除字符串左端指定的内容

rstrip函数

功能：去除字符串右端指定的内容

运算符家族

+：

字符串拼接操作

*：

字符串复制

孤儿家族

count函数

功能：统计子字符串在原字符串出现的次数

返回值：出现的次数

join函数

功能：将容器（列表中)的字符串拼接起来

返回值：拼接好的字符串

python数据类型

列表：

列表是一种容器，可以存放任意类型的数据

访问

列表是支持下标进行访问的

下标：从左到右，下标从0开始，

从右到左，下标从-1开始

列表也支持切片访问的

语法：var变量[ 初始位置：终止位置：步长 ]

列表的增删改查

len函数：

指定要进行长度统计的字符串

a='www.PaAey.net'

>>>len(a) #输出13

排序

c语言中，冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

sort函数：排序

元组

概念：

元组也是一个容器，可以存放数据（int bool，str......）,元组里面的内容不可以进行修改

只有访问和查找

支持下标和切片进行访问

查找：in not in count

字典

概念：字典也是容器，使用{}，{}里面的值，以key和value类型存在

注意：字典的key必须是不可以改变的类型：字符串，数字。元组

字典里面的底层原理是用红黑树实现的

红黑树

每个节点不是红色就是黑色

根节点必须是黑色

每个叶子节点都有null节点，颜色都是黑色

如果一个节点是红色，那么它的子节点必须是黑色（不能连续红色）

从一个节点到该节点的所有子节点包含相同的黑色节点

字典的定义

dic ={"name":"小白"}

字典的访问

#字典的增删改查
stu={"name":"张三","age":18}

#字典是可以根据key值进行访问
print("my name is %s,age is %d" % (stu["name"],stu["age"]))

# 字典访问不存在的key，会直接报错
# print("my name is %s,age is %d,my father is %s" % (stu["name"],stu["age"],stu["father"]))

# get函数通过key值进行访问
print("my name is %s,age is %d,my father is %s" % (stu.get("name"),stu.get("age"),stu.get("father")))

# 添加元素到字典中
'''
dict[不存在的key]=value
'''
stu["father"]="张二"
stu["mother"]="小美"
stu["aunt"]="小姨"
print(stu)
for i in stu:
    print(i,stu[i])

# 字典的修改
'''
dict[key]=new_value
'''
print("修改后的内容")
stu["father"]="张一"
for i in stu:
    print(i,stu[i])

# 字典的删除
'''
del dict[key]
'''
del stu["mother"]
del stu["aunt"]
print("删除之后的内容")
for i in stu:
    print(i,stu[i])

# 清空字典中所有的内容
'''
dict.clear()
'''
stu.clear()
print("清空之后的内容")
for i in stu:
    print(i,stu[i])



# 字典的查找
'''
字典的查找，本质上 in    not in
len：字典当中的键值对的个数
keys:字典当中的key:values当中的所有的key值
values:字典当中的key：value里面的所有的value值
items: 字典当中的所有的key：value

'''
print("stu字典中的key：value的个数",len(stu))
print("stu字典中的key：value中的所有的key值",stu.keys())   #配合in   not in来进行使用
print("name in stu.keys:", "name" in stu.keys())          #查询name是否在stu中  True/False
print("stu中所有的value值:",stu.values())                 #查询字典当中的key：value里面的所有的value值
print("stu中所有的key：value内容:",stu.items())           #查询字典当中的所有的key：value

#  items 是可以在遍历的时候进行使用
for key,value in stu.items():
    print(key,value)

函数

概念：完成特定的功能的一段代码，高内聚，低耦合。本质：方便代码复用

函数的定义

def 函数名（形式参数列表）：

      函数体

函数的调用

函数名(实际参数列表)

形式参数与实际参数的区别：

         形式参数是实际参数的一份临时拷贝

#定义两个数相加的函数

def sum(x,y):     #形式参数没有类型的限制  
    return x+y                  
print(sum(10,20))               
print(sum("father","mather"))   

函数返回值

python中的函数支持返回多个值

使用和返回值相同数量的值，进行接收

def fun(x,y):
    add=x+y
    sub=x-y
    mul=x*y
    div=x/y
    return add,sub,mul,div

add,sub,mul,div=fun(10,5)
print("add :",add)
print("sub :",sub)
print("mul :",mul)
print("div :",div)

使用一个进行接收，但是输出结果会被打包成元组

def fun(x,y):
    add=x+y
    sub=x-y
    mul=x*y
    div=x/y
    return add,sub,mul,div

ret=fun(10,5)
print(ret)

参数

缺省参数

在定义函数的时候，给参数进行默认赋值，当调用的时候没有给出该参数的时候，会自动使用缺省函数进行赋值

默认值从右向左给出

作用：使调用更加灵活

def info(name,age=6):
    print("my name is %s  age is %d"%(name,age))
info("xxx",5)
info("mmm")

不定长参数

形式参数前面加上    *     可以将多余参数打包成元组使用

def info(name,age,*hobby):

    print("my name is", name)
    print("my age is", age)
    print("my hobby is",hobby)
info("xxx",5,"吃饭","睡觉","打豆豆")

递归函数

概念：

函数调用函数本身

条件：

            递归要有结束条件

           每次递归，都要向递归结束条件靠近

递归函数的时间复杂度：

递归的次数 × 每一次递归函数的时间复杂度

#阶乘

#计算阶乘
def fun(x):
    # 结束条件
    if x==1:
        return 1
    return x*fun(x-1)
ret=fun(3)
print(ret)

#斐波那契数列

#斐波那契数列
def fun(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fun(n-2)+fun(n-1)

print(fun(3))

fun(50)算不出来或者说需要很久

原因：时间复杂度是2的n次方

递归的使用场景

优点：简单

缺点：代码理解起来会很复杂

应用场景：

                1.能想得到

                2.对时间和空间没有太大的影响

递归的面试

青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

                        斐波那契变形

        思路1：

                        1阶：1

                        2阶：2

                        3阶：3

                        4阶：5

                        5阶：7

        思路2：剩余台阶数    n-1 或者 n-2

局部变量与全局变量

局部变量：

函数内部声明的变量叫做局部变量

全局变量

函数外部声明的变量叫做全局变量

number=100
def fun():
    number=200
fun()
print(number)

关键字global

声明使用的是全局变量 

简单的学生管理系统

'''
学生管理系统

描述学生：数据类型：字典       {"name":name,"age":age,"score",score}
容器选择：列表  [{},{},{}]
'''
#定义一个全局变量class_info 班级信息
class_info=[]

def print_menu():
    print("---------------------------")
    print("学生管理系统")
    print("1.添加学生")
    print("2.删除学生")
    print("3.修改学生")
    print("4.查询学生")
    print("5.显示所有学生")
    print("6.退出系统")
    print("---------------------------")

#添加学生的函数
def add_student():
    #声明使用全局变量
    global class_info
    name=input("please input your name")
    #不想执行，退出到主页面
    if name=="quit":
        return main()

    age = input("please input your age")
    score = input("please input your score")


    #姓名的验证，不能有重复的名字
    for student in class_info:  #class_info =[{},{},{}]
        if student["name"]==name: #说明学生姓名重复
            print("学生已经存在")
            return
    #学生没有被添加过
    student={
        "name":name,
        "age":age,
        "score":score
    }
    #将学生信息插入列表
    class_info.append(student)   #class_info =[{'name':'zhangsan','age':'18','score':'90'}]
    print("插入成功")


#删除学生的函数
def del_student():
    global class_info   #声明使用全局变量

    #根据姓名删除学生
    name=input("输入要删除的学生姓名")
    if name=="quit":
        return main()

    #根据学生的姓名去class_info中寻找
    for student in class_info:
        if student["name"]==name:
            class_info.remove(student)
            print("删除成功")
            return
    #循环外就是学生不存在
    print("学生不存在")
    return None

#修改学生信息的函数
def rev_student():
    global class_info     #声明使用全局变量
    name=input("输入要修改学生的姓名")
    if name=="quit":
        return main()
    for student in class_info:
        if student["name"] == name:
            student["name"]=input("输入修改后学生的名字")
            student["age"] = input("输入修改后学生的年龄")
            student["score"] = input("输入修改后学生的成绩")
            print("修改成功")
            return
    print("学生姓名错误")
    return None

#查询学生信息的函数
def find_student():
    global class_info  # 声明使用全局变量
    name=input("输入你要查询的学生姓名")
    if name=="quit":
        return main()
    for student in class_info:
        if student["name"] == name:
            print("name",student["name"])
            print("age", student["age"])
            print("score", student["score"])
            print("查询成功")
            return
    print("查询失败")
    return None

#显示所有学生的函数
def show_student():
    global class_info  # 声明使用全局变量

    #遍历学生信息
    print("%10s %10s %10s %10s" % ("序号","姓名", "年龄", "成绩"))
    i=1
    for student in class_info:
        print("%10s %12s %12s %12s" % (i,student["name"],student["age"],student["score"]))
        i+=1
    return None


def main():
    while True:
        print_menu()    #打印功能菜单
        choose=int(input("please input your choose"))   #选择功能
        if choose==1:
            add_student()
            print(class_info)
        elif choose==2:
            del_student()
        elif choose==3:
            rev_student()
            print(class_info)
        elif choose==4:
            find_student()
        elif choose==5:
            show_student()
        elif choose==6:
            print("byebye")
            break
        else:
            print("输入有误，请重新输入")
            continue

main()

文件系统

概念

文件：持久化存储数据

文件的相关操作

文件的基本操作：

        打开文件：open

        关闭文件：close

        读写文件：read  readline  write   writelines

运行后多出一个111.txt文件

with 上下文管理器：打开文件后，不需要手动关闭文件，自动管理文件的关闭

        格式：

                 with open（地址，打开方式）as 临时变量：

                        临时变量就是打开的文件

写

读

readline()默认读取一行

OS模块

导入OS模块：import os

os.rename(src，dst)    将原来的src文件命名为dst

运行后

当文件不存在的时候，会报错

os.remove 将文件删除

#如果删除的文件不存在，会报错

运行后

os.listdir():  获取指定路径下的所有的文件名

将指定路径下的文件，全部修改成txt文件

运行后

面向对象编程

面向对象与面向过程

面向对象：将事情委托给擅长这件事情的人来完成         C++，Java Python

面向过程：强调的是过程，所有的事情，全部都是由自己完成           C语言

类与对象

类：类型，一般是一个泛指，指 的是一类物体（具有相同的属性和方法）

对象：类的具体的实例化，一般情况是特指一个物体

类与对象的关系：

        类是创建对象的模版

类的组成：

        类一般由三部分组成：

        类名        属性：一组数据        方法：函数

面向对象的特点：

        封装：将属性与方法封装到一起

        继承：类级别的代码复用

        多态：函数的多种形态

        抽象：将具体的内容，转换成数据

抽象：

        类名：SunFlower

        属性：图片，HP

        方法：摇动，产生阳光

定义类：

经典类：

#经典类
class GrilFriend:

    #属性
    sex="女"
    age=18

    #类方法
    @classmethod
    def cook(cls):
        print("女孩子天生就会做饭")

    #对象的方法：实例的方法
    def shopping(self):
        print("女孩子喜欢购物")

新式类：

#新式类
class GirlFriend(object):
    #object :python当中最顶级的父类
    sex="女"
    age=18

    #类方法
    @classmethod
    def cook(cls):
        #cls:类本身
        print("女孩子天生会做饭")

    #定义对象的方法
    def shopping(self):
            #self：类似C++当中的this指针，self指的是对象
        print("女孩子喜欢购物")

定义对象

格式：对象名=类名（）

一个类可以创建多个对象

class GirlFriend(object):
    #object :python当中最顶级的父类
    sex="女"
    age=18

    #类方法
    @classmethod
    def cook(cls):
        #cls:类本身
        print("女孩子天生会做饭")

    #定义对象的方法
    def shopping(self):
            #self：类似C++当中的this指针，self指的是对象
        print("女孩子喜欢购物")

    #通过类创建对象
white=GirlFriend()

#对象调用类方法
white.cook()
white.shopping()

实例方法与类方法的区别

class GirlFriend(object):
    #object :python当中最顶级的父类
    sex="女"
    age=18

    #类方法
    @classmethod
    def cook(cls):
        #cls:类本身
        cls.age=20
        print("女孩子天生会做饭")

    #定义对象的方法
    def shopping(self):
            #self：类似C++当中的this指针，self指的是对象
        print("女孩子喜欢购物")

    #定义change方法修饰属性
    def change(self):
        self.sex="男"
        self.age=20


    #通过类创建对象
white=GirlFriend()

#对象调用类方法
white.change()
white.cook()
print(white.sex,white.age)


black=GirlFriend()
print("black.age=",black.age)

类方法：

        类名和对象都可以访问，但是类方法可以修改类属性

实例方法：

        对象进行调用，不可以修改类属性，只可以修改对象的属性（实例属性）

类方法不可以访问实例方法

魔法方法：

__init__魔法方法

        __init__不是创建对象的方法，是初始对象的方法

特点：

        不需要手动调用，在创建对象的时候，会自动调用

        __init__是可以进行传参的

class GirlFriend(object):
    #object :python当中最顶级的父类
    sex="女"
    age=18

    #定义对象的属性
    def __init__(self,hair="黑发",eye="大眼睛"):
        self.hair=hair
        self.eye=eye

    #类方法
    @classmethod
    def cook(cls):
        #cls:类本身
        cls.age=20
        print("女孩子天生会做饭")

    #定义对象的方法
    def shopping(self):
            #self：类似C++当中的this指针，self指的是对象
        print("女孩子喜欢购物")

    #定义change方法修饰属性
    def change(self):
        self.sex="男"
        self.age=20

    #定义一个方法，自我介绍
    def show(self):
        print("我的头发是：%s，眼睛是：%s"%(self.hair,self.eye))

#不传参数的时候，使用的是缺省参数
white=GirlFriend()
white.show()
black=GirlFriend("大波浪","卡姿兰大眼睛")
black.show()

        __del__魔法方法

功能：       

          __del__不是删除对象的方法，在删除对象，回收资源的时候，会自动调用这个函数

特点：

        在程序执行完毕或者调用del关键字删除对象的时候，会进行调用

class GirlFriend(object):
    #object :python当中最顶级的父类
    sex="女"
    age=18

    #定义对象的属性
    def __init__(self,hair="黑发",eye="大眼睛"):
        self.hair=hair
        self.eye=eye
        self.file=open("./1.txt","w")   #理论上有一定的资源

    #类方法
    @classmethod
    def cook(cls):
        #cls:类本身
        cls.age=20
        print("女孩子天生会做饭")

    #定义对象的方法
    def shopping(self):
            #self：类似C++当中的this指针，self指的是对象
        print("女孩子喜欢购物")

    #定义change方法修饰属性
    def change(self):
        self.sex="男"
        self.age=20

    #定义一个方法，自我介绍
    def show(self):
        print("我的头发是：%s，眼睛是：%s"%(self.hair,self.eye))

    #定义__del__方法回收资源
    def __del__(self):
        print("-------------开始回收资源---------------")
        self.file.close()
        print("-------------回收资源结束---------------")

#不传参数的时候，使用的是缺省参数
white=GirlFriend()
white.show()

####

__str__魔法方法

功能：

        返回一个字符串，当打印对象的时候，会自动打印出__str__函数返回的内容

特点：

        调用print打印对象的时候，才会主动调用

继承

概念：

        子类继承父类的属性和方法

继承是指类与类之间的关系，对象和对象之间不可以继承

     

class A(object):
    money=100

#继承是指子类继承父类的属性和方法
class B(A):   #B继承A
    pass   

#pass表示一个占位符，如果没有程序不完整，会报错，添加pass表示，这里没有任何内容，是空的

b=B()
print(b.money)