Python数据分析——python基础回顾-CFANZ编程社区

纯个人python的一个小回忆笔记，当时假期花两天学的python，确实时隔几个月快忘光了，为了应付作业才回忆起来，不涉及太多基础，适用于有一定编程基础的参考回忆。

一、输入输出

【输入】

【输出】

二、判断

三个跟别的编程语言不同的地方：

三、循环

【while循环】

【for循环】

多3个跟别的编程语言不同的地方：

1、字符串可以直接【变量 in 字符串】

2、用range()函数来循环

四、变量的数据类型

首先python不需要定义数据类型，这跟JavaScript一样

1、字符串

#基本语法大差不差,不过记住字符串只可读不可改
s1 = "skdjfjsf操!"
s2 = "jdh kljd lksd lksdj"
s3 = " dkjhskd "
s4 = "12dk12sj211212"

#index获取字符下标
print(s1.index("操"))
# split(): 根据()里的参数来分割字符串，将分好的子串装到一个字符串列表返回
print(s2.split(" "))
# strip(): 去除字符串两端的空格
print(s3.strip())
# strip(): 有【字符串参数】时，去除字符串里含有的所有的这个【字符串参数】
print(s4.strip("12"))
# len(): 获取字符串的长度
print(len(s1))
# count(): 统计字符串里某个字符出现的次数
print(s1.count("s"))

2、数据容器（列表、元组、字符串、集合、字典）

记住他们几种类型的定义方法：（他们都可以装任何类型数据，不限制，杂交着来）

1）列表list

定义初始化的列表变量两种方法

【添加元素】：【append】方法添加元素，跟Java的List有点像

【删除元素】：

【统计元素长度】：【len()】

【统计某个元素在列表有几个】：【count()】

（跟字符串一样）

【通过负数索引从后往前获取元素】

【循环】

2）元组tuple

理解为一个只读的list，一旦元素被定义就不可以被修改

定义初始化元组的两种方式

【统计元素长度】：【len( )】

【统计某个元素在列表有几个】：【count( )】

（还是跟字符串一样）

【循环】（跟列表list一样）

【拓展：虽然元组内元素不能修改，但是如果里面嵌套的是list列表，那就可以修改】

3）集合set

set就是在list的基础上，自动去重复，而且无序（list、set、tuple都支持重复元素）

集合set的初始化定义方法

【添加元素】：【add】方法添加元素（不加重复元素）

【删除元素】：

大致跟list一样，只是两点不一样：

1、没有del这个删除方式

2、set的pop是从头部去除，list的pop是从尾部

【统计元素长度】：【len()】

（跟字符串一样，因为都是去重的结果，所以就没count的必要来统计某个元素有几个了，都是1个）

【合并两个集合】

【取两个集合不一样的地方】：

【新集合 = 集合2.difference(集合1)】（不改变两个原集合，返回一个新集合）

【集合2.difference_update(集合1)】（改变集合2，去掉二者一样的部分）

4）字典dict

定义初始化的字典变量的两种方法

不允许重复【键】

【字典】跟别的数据容器不一样，他是键值对的，所以没有索引下标，要用【字典["键"]】这样获取元素值

【增删改查】也跟json差不多，我就直接放截图了，除了删是【字典.pop("键")】

【获取“键名”】

【循环取值】跟别的数据容器大差不差

【长度】也一样

五、序列

序列就是对元组、列表、字符串这些数据容器【切片】，取出符合需求的子序列

1）格式

记住标准完整格式是【起始下标 : 结束下标 : 步长】

那么通常默认【起始位——>0】，默认【步长——>1】，所以起始位如果是从0开始，而且连续一个一个截取的话，那就可以省略【起始位】和【步长】不写（但是起始位的 ":" 这个符号不能省略）

当然如果从头截取到尾部的话，【起始位】、【末尾位】都可以省略，但是它两的 “:” 符号不能省略

【步长】是负数的话就是反着取

#序列就是对元组、列表、字符串这些数据容器【切片】，取出符合需求的子序列
#格式就是：【起始下标 : 结束下标 : 步长】
#这里【步长】默认是1，所以步长为1的话可以不写；如果想反过来取，就写负数
#如果要的是整个内容的话。那么【起始】【结束】也可以省略，但是【:】不可以省略
#【结束】下标不包括该下标位置

mylist = [0,1,2,3,4,5,6]
mytuple = (0,1,2,3,4,5,6)
mystr = "0123456"



#取mylist第0到第4位
r1 = mylist[0:4:1] #【结束】下标不包括该下标位置
print(r1, end="  ")

r1 = mylist[:4] #简写
print(r1)



#取mytuple全部，每间隔1个取一个
r2 = mytuple[0:7:2] #【结束】下标不包括该下标位置
print(r2, end="  ")

r2 = mytuple[::2] #简写
print(r2)



#取mystr反过来的结果
r3 = mystr[6:0:-1]  #倒着取的时候，【起始】【结束】要倒换过来
print(r3, end="错  ") #另外到头的话就别写【结束】下标，因为-1下标代表最后一位，而【结束】下标又不包括当前下标，那么就取不到第【0】位

r3 = mystr[::-1]
print(r3, end="对\n")



#取mylist第5位到头，反着取，并间隔两个取
r4 = mylist[5::-2]
print(r4)

六、函数

写法：跟别的编程语言差不多，只不过要加个【def】，然后没有花括号，要靠缩进

【def 函数名( )】或【def 函数名(参数)】

带参数的函数的几种传参写法：

【重点】一种特殊的python特有的函数：【lambda函数】

七、类

逻辑上是跟java一样的，我就不讲太多了，直接看代码

1）创建类

java是【public class 类名】，python是【class 类名】

2）成员变量

一样的，定义初始化的普通成员变量就是【变量 = None】

像java里的类一般都设置【私有成员变量】，不让外界随便通过【对象.成员变量 = xxx】这样改错误的值，那么python一样

3）构造方法

python和java一样都有构造方法，不写的时候就默认一个空参构造方法，写了有参构造方法就会方便创建实例化对象的时候直接给成员变量赋值。

但是python有一个便捷的地方就是，它不用根据有没有参数、或者有几个参数来写对应的构造参数，因为【python函数】里有【异位函数】和【带默认值参数的函数】

简单放一个java的例子（要写这么多）

但是python只需要写一个构造函数

4）getter和setter方法

python也有单独设置一个变量、获取一个变量的getter、setter方法，跟java大差不差的

5）python特有便捷创建成员变量方法

有一点跟java不一样，java里要有的成员变量必须一开始就写好

6）实例化对象调用

跟java一样，类要实例化成对象才能用，但是不用像java那样【new 类()】

八、魔法方法

python的类里有一些叫【魔法方法】的函数，可以更方便的在外部调用时，直接获得我们要的结果

1、【str(self)】

字符串输出整个对象的信息

这个函数没有参数，所以只用带个self就行，返回出去的是自己类里的东西

2、【lt(selft, other)】和【le(self, other)】

比较两个对象的某个成员变量（属性）大小关系

这2个函数因为要跟别的对象对比，所以要传入别的对象参数，同一类型的对象参数用other代表

注意这里return的结果是我们自己对的比较规则的结果，返回的是布尔值，你可以任意根据实际觉得return这里要比较的是什么属性，是小于还是大于......

3、【eq(self, other)】

比较两个对象是否一样

这个函数因为要跟别的对象对比，所以要传入别的对象参数，同一类型的对象参数用other代表

全部代码

class myClass:
    name: None
    age: None
    sex: None
    phone: None

    # 构造方法
    def __init__(self, name=None, age=None, sex=None, phone=None):
        self.name = name
        self.age = age
        self.sex = sex
        self.phone = phone
        # if name is not None and age is not None and sex is not None and phone is not None:
        #     print("构建一个完整对象完毕\n")
        # else:
        #     print("构建一个空对象完毕\n")
    # __str__魔法方法：字符串输出对象
    def __str__(self):
        return f"这个对象是：name：{self.name}, age: {self.age}, sex: {self.sex}, phone: {self.phone}"
    # __lt__魔术方法：比较对象属性大小(只可以比>、<关系)
    def __lt__(self, other):
        return self.age < other.age
    # __le__魔术方法：比较对象属性大小(只可以比>=、<=关系)
    def __le__(self, other):
        return self.age <= other.age
    # __eq__魔术方法：比较对象是否相等
    def __eq__(self, other):
        return self.age == other.age and self.name == other.name and self.phone == other.phone and self.sex == other.sex

# 测试__str__魔法方法：字符串输出对象
classA = myClass("尚阿比", 25, "男", "122345678")
print(classA)

# 测试__lt__魔术方法：比较对象属性大小(只可以比>、<关系)
classB = myClass("麦克阿瑟", 30, "男", "122345678")
print(classB > classA)
print(classB < classA)

# 测试__le__魔术方法：比较对象属性大小(只可以比>=、<=关系)
print(classB >= classA)
print(classB <= classA)

# 测试__eq__魔术方法：比较对象是否相等
classC = myClass("尚阿比", 25, "男", "122345678")
print(classB == classA)
print(classC == classA)