Python数据分析——python基础回顾

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

一、输入输出

【输入】

无提示语：【变量 = input()】

有提示语：【变量 = input("提示语")】

【输出】

只用记这一个，反正别的我也觉得不常用

【print(f"字符串{变量}")】（加个f"..."这样就可以输入变量值，但是变量要在""里用{}包起来）

有一个地方要注意一下：print函数有一个【end参数】，默认值为换行符\n，把它的值换了就不会自动换行了

想以空格为每次输出的结尾【间隔】，就

二、判断

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

1、判断条件不需要中括号()包起来

2、没有花括号，python层级关系靠Tab代码缩进

3、【else-if】写成【elif】

三、循环

大体上也就2个地方跟别的编程语言不同：

1、循环结束的判断条件不需要中括号()包起来

2、没有花括号，python层级关系靠Tab代码缩进（重点，很容易出错）

【while循环】

【for循环】

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

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

2、用range()函数来循环

1）【变量  in  range(a)】表示变量从0遍历到a（但不包括a，遍历到a前一个数字）

；

2）【变量  in  range(a,b)】表示变量从a遍历到b（但不包括b，遍历到b前一个数字）

；

3）【变量  in  range(a,b,c)】变量从a遍历到b，每下一轮遍历都是上一次的【+c】步长

；

4）【变量  in  range(a,b,c)】当a>b，而且c这个步长是负数，那就是倒序循环遍历

四、变量的数据类型

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

1、字符串

【找某个字符下标位置】：【字符串.index("字符")】

；

【分隔字符串子串】：【字符串.split("字符串")】（返回的是列表数据类型，类似java的数组）

；

【去除字符串两端空白字符】：【字符串.strip()】

【专门去除某个字符串】：【字符串.strip("字符串")】

；

【字符串长度】：【字符串.len()】（基本所有类型数据都是用len()求长度，比如列表、集合、字典......）

；

【统计某个字符在字符串出现几次】：【字符串.count("字符")】

#基本语法大差不差,不过记住字符串只可读不可改
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、数据容器（列表、元组、字符串、集合、字典）

c语言里装多个数据的容器有：数组、链表......

java有：数字、集合、哈希表......

python有：【list列表、tuple元组、str字符串、set集合、dict字典】

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

列表使用: [ ]
元组使用: ( )
字典、集合使用: { }
但是集合还有“键值对”: { "键":"值" }

1）列表list

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

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

【删除元素】：

【del 列表[下标]】：已知下标，删除指定位置的元素

list2 = [1, 2]
del list2[1]  # ——> list2 = [1]

【列表.pop( )】：循环删除时自动删除列表最后一个元素

list3 = ['a', 'c', 'b']

for i in range(2):
    element = list3.pop()
    print(f"移除了{element}")
# ——> list3 = ['a', 'c'] ——> ['a'] ——> []

【列表.remove( 元素 )】：已知某个元素，删除该元素

list4 = ["aa","bb","cc","dd","ee","aa"]
list4.remove("aa") # ——> list4 = ["bb","cc","dd","ee"]

【列表.clear( )】：全部清空

list4 = ["aa","bb","cc","dd","ee","aa"]
list4.clear() # ——> list4 = []

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

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

（跟字符串一样）

list4 = ["aa","bb","cc","dd","ee","aa"]

#统计一个列表所有成员有几个
length = len(list4)
print(f"list4有{length}个") # ——> 6


#统计其中一个元素的个数
sum = list4.count("aa")
print(f"'aa'有{sum}个") # ——> 2

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

#还可以嵌套成二维、三维列表
list1 = [[1, 2] , ['a', 'b']]

#通过负数索引反向获取：-1就等于java的length-1
print(list1[-1]) # ——> ['a', 'b']
print(list1[-2]) # ——> [1, 2]

【循环】

 【while循环】

index = 0
while index < len(list4):
    print(list4[index], end=" ")
    index += 1

【for循环】

#遍历下标索引
for i in range(0,len(list4)):
    print(list4[i], end=" ")

#直接遍历元素（类似Java的for-in：for(int a: list)）
for i in list4:
    print(i, end=" ")

2）元组tuple

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

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

注意元组一个元素的时候，必须后面带逗号，否则就是字符串了

#注意元组一个元素的时候，必须后面带逗号，否则就是字符串了
tuple4 = ("xxx")
tuple5 = ("xxx",)

print(type(tuple4)) # ——> 类型是字符串<class 'str'>
print(type(tuple5)) # ——> 类型是元组<class 'tuple'>

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

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

（还是跟字符串一样）

#count统计某个成员数量
print(tuple1.count("aaa"))

#len统计元组所有成员数量
print(len(tuple6))

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

index = 0
while index < len(tuple1):
    print(tuple1[index], end=" ")
    index += 1
print()

for i in tuple1:
    print(i, end=" ")

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

#元组不可修改，但是如果里面套list就可以修改list成员
t = (1,2,["one", "two"])

t[2][0] = "一"
t[2][1] = "二"
print(t)  # ——> (1,2,["一", "二"])

3）集合set

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

s1 = {1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,}
print(f"set会去重: {s1}")

集合set的初始化定义方法

；

注意：【set = { }】可不是定义空集合的写法，这是定义【空字典】

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

【删除元素】：

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

1、没有del这个删除方式

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

【集合.pop( )】：循环删除时自动删除列表最后一个元素

set1 = ['a', 'c', 'b']

for i in range(2):
    element = set1.pop()
    print(f"移除了{element}")
# ——> set1 = {'c' , 'b'} ——> {'b'} ——> {}

【集合.remove( 元素 )】：已知某个元素，删除该元素

set2 = {1, 2, 3, "aa"}
set2.remove("aa") # ——> set2 = [1, 2, 3]

【集合.clear( )】：全部清空

set3 = {"aa","bb","cc","dd","ee"}
set3.clear() # ——> set3 = {}

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

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

set3 = {"aa","bb","cc","dd","ee"}

#统计一个列表所有成员有几个
length = len(set3)
print(f"set3有{length}个") # ——> 5

 【合并两个集合】

#合并
s1 = {1,2,3,4,5}
s2 = {3212312,3,899,0.22,"asas",2}
s3 = s1.union(s2)
print(s3) # ——> {0.22, 1, 2, 3, 4, 5, 899, 3212312, 'asas'}

【循环】：都一样的我就不写了

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

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

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

#取两集合不同的地方
s1 = {1,2,3,4,5}
s2 = {3212312,3,899,0.22,"asas",2}
s3 = s2.difference(s1) #获得s2里跟s1不一样的元素
print(s3) # ————> 新集合s3 = {0.22, 3212312, 899, 'asas'}

#上一个不会改变原集合，这个是修改原集合
s1 = {1,2,3,4,5}
s2 = {3212312,3,899,0.22,"asas",2}
s2.difference_update(s1) #把s2里跟s1一样的部分去掉
print(s2) # ————> 原集合s2 = {0.22, 3212312, 899, 'asas'}

4）字典dict

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

；

我说白了，这玩意就是json吧.......，他就是【键值对】形式的数据容器

不允许重复【键】

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

；

基本跟json一样，可一直嵌套，但是记住【键】也要写成【"键"】字符串形式

【增删改查】也跟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 函数名(参数)】

注意:必须让函数在【调用它的地方】的【前面】

有返回值的话就return，所有编程语言都一样的，只不过python函数可一次返回多个不同类型的值

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

【同为参数】，【函数形式参数】跟【调用函数传去的实际参数值】位置一一对应，就自动匹配上参数跟值

；

【异位参数】，位置没有对上的时候，就得在【调用函数

；

【自带默认值】，就不用传参也不会报错，自己本来就有默认值

；‘

【不定长参数】，不确定调用函数时会传几个参数时用

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

当有的函数的函数体里只有一句话的时候，而且有返回值，就可以用它

七、类

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

1）创建类

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

2）成员变量

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

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

java是由成员变量是【private 数据类型 变量】，python是【__变量 = None】

3）构造方法

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

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

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

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

1、构造函数是【__init__】

；

2、参数括号第一位是【self】，就等于java的【this】

；

3、所有成员变量参数都可以写上去，只要写好默认值，那么创建这个类的实例化对象的时候，不管是传一个参数值、还是空参、还是全传，都可以对应上这个构造函数

；

4、java的【this.变量 = 变量】，在python是【self.变量 = 变量】

4）getter和setter方法

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

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

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

但是python里可以不写，你在类的其他任意一个函数里用【self.变量 = 值】就又可以给类添加一个成员变量了

（本来没有name这个变量，在这个createName函数里又给它加上了，在外面如果不调用这个函数，这个类就没有这个变量）

6）实例化对象调用

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

python的空参实例化对象

python的有参实例化对象

八、魔法方法

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

1、【__str__(self)】

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

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

只需要在这个方法里return 一个我们希望输出这个对象信息的字符串形式，就可以直接输出结果

；

如果不写这个方法，当我们想输出对象信息，得到的结果不是我么们要的

；

有了【__str__(self)】之后，可以按我们希望的形式展示对象信息

2、【__lt__(selft, other)】和【__le__(self, other)】

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

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

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

注意【__lt__(selft, other)】只可以比>、<关系

；

【__le__(self, other)】只可以比>=、<=关系

3、【__eq__(self, other)】

比较两个对象是否一样

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

注意这里return的结果是我们自己对的比较规则的结果，返回的是布尔值，你可以任意根据实际觉得return这里要比较的是什么属性相等，一个属性也行、所有属性都相等也行......

全部代码

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)

 

八、模块

就是代码最顶部的那些【import ...】

我们平时引用一些工具库的API，就需要用【import ...】来导入这个工具库模块，那么我们自己也可以写一个自己的模块

1、写一个模块

一个模块可以就是一个简单的py文件，你想写啥写啥，一般有几个属性、几个函数够了

也可以是一个包，包里的所有文件也都包含在这个模块里

2、导入模块

我们平时用到一些组件库大部分都是【import ...】，那是因为这是python当前目录下内置已有的模块，当然有的路径不一样或者多个模块里又相同的库需要导入，那就需要用【from ... import ...】

意思就是你要从哪一个模块【from...】，导入它里面的哪一个东西【import ...】

那么我们要导入自己的模块，就要先【from...】找到这个模块的路径地址

不知道具体路径在哪的话，可以右键选【复制路径/引用...】

这两都可以，当然如果这个模块跟你要用的地方的文件是同一级目录下，你直接【from 他的文件名】就行

1) 只引用其中部分内容功能

那么如果你不需要导入整个模块，只需要这个模块里的其中某些东西，那就要带上【import ...】

就比如整个bs4这个模块库很大，但是我只需要用到里面的BeautifulSoup，那我就只用写【from bs4 import BeautifulSoup】

这样引入之后，如果想要调用这些内容（属性、类、函数），就跟调用对象的内容一样

【模块.属性】【模块.函数()】【模块.类()】

如果调用模块的类的东西，还要多套几层

2)还可以使用别名

有的模块名字太长了，如果还是 “模块的类的属性” 这样的东西，还要套好多层

那我们还可以用别名的方式，写成【别名.属性】【别名.函数()】【别名.类()】

写法【import ... as 别名】

3）还可以使用【import *】引入模块里所有的内容

【*】 代表 【所有】，用了【*】之后，模块里面的内容即使不用【别名】，也可以直接使用

4）另外两个特有变量

【__all__】

这变量可以理解为【类里的私有化成员】，【__all__ = ['属性','函数名','类名']】这样写了之后，当外部引用这个模块的时候，这个模块里除了【__all__ = ['属性','函数名','类名']】之外的成员都不能被用

【__name__】

这个变量是控制模块内哪些函数在自己本地文件运行时会触发，在外部导入时不会被触发

因为一个模块导入，如果这个模块本身里面又函数被执行，那么在导入模块时，这个函数也会被自动触发

；

那么当我们只希望这个函数在这个模块自己运行时才执行，在外部调用时不要被执行，那就加上这句判断【if __name__ == '__main__': [不想被执行的函数]】

以上便是大致的python基础，再往后的python爬虫、大数据分析都会用到，别的也没什么好学的，往后接触项目再涉及即可