python基础

最新推荐文章于 2022-03-24 21:25:57 发布

慢慢慢时光

最新推荐文章于 2022-03-24 21:25:57 发布

阅读量430

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/wjl31802/article/details/88428323

版权

python 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

在学习java接触框架之后对之前所学python又有了新的认知，抽空对照java复习python语法并进阶数据分析

day01 pycharm的初始设置

1. 恢复 PyCharm 的初始设置

PyCharm 的 配置信息 是保存在 用户家目录下 的 .PyCharmxxxx.x 目录下的，xxxx.x 表示当前使用的 PyCharm 的版本号如果要恢复 PyCharm 的初始设置，可以按照以下步骤进行：

1. 关闭正在运行的 PyCharm
1. 在终端中执行以下终端命令，删除 PyCharm 的配置信息目录：

$ rm -r ~/.PyCharm2016.3

1. 重新启动 PyCharm

2. 第一次启动 PyCharm

导入配置信息
选择许可协议
配置初始界面

03. 新建/打开一个 Python 项目

3.1 项目简介

开发项目就是开发一个 专门解决一个复杂业务功能的软件
通常每 一个项目 就具有一个 独立专属的目录，用于保存 所有和项目相关的文件
- 一个项目通常会包含 很多源文件

3.2 打开 Python 项目

直接点击 Open 按钮，然后浏览到之前保存 Python 文件的目录，既可以打开项目
打开之后，会在目录下新建一个 .idea 的目录，用于保存 项目相关的信息，例如：解释器版本、项目包含的文件等等
第一次打开项目，需要耐心等待 PyCharm 对项目进行初始设置

设置项目使用的解释器版本

打开的目录如果不是由 PyCharm 建立的项目目录，有的时候 使用的解释器版本是 Python 2.x 的，需要单独设置解释器的版本
通过 File / Settings… 可以打开设置窗口

3.3 新建项目

1) 命名规则

以后 项目名 前面都以 数字编号，随着知识点递增，编号递增
- 例如：01_Python 基础、02_分支、03_循环…
每个项目下的 文件名 都以 hm_xx_知识点 方式来命名
- 其中 xx 是演练文件的序号
注意
- 1. 命名文件名时建议只使用 小写字母、数字和 下划线
- 1. 文件名不能以数字开始
通过 欢迎界面 或者菜单 File / New Project 可以新建项目

2) 演练步骤

新建 01_Python基础 项目，使用 Python 3.x 解释器
在项目下新建 hm_01_hello.py Python 文件
编写 print("Hello Python") 代码

day02 python的语法

1. 注释

1. 单行注释

以 # 开头，# 右边的所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用

# 这是第一个单行注释
print("hello python")

为了保证代码的可读性，# 后面建议先添加一个空格，然后再编写相应的说明文字

2. 在代码后面增加的单行注释

在程序开发时，同样可以使用 # 在代码的后面（旁边）增加说明性的文字
但是，需要注意的是，为了保证代码的可读性，注释和代码之间 至少要有 两个空格
示例代码如下：

print("hello python")  # 输出 `hello python`

3. 多行注释（块注释）

如果希望编写的 注释信息很多，一行无法显示，就可以使用多行注释
要在 Python 程序中使用多行注释，可以用 一对连续的三个引号(单引号和双引号都可以)
示例代码如下：

"""
这是一个多行注释

在多行注释之间，可以写很多很多的内容……
""" 
print("hello python")

什么时候需要注释

注释不是越多越好，对于一目了然的代码，不需要添加注释
对于 复杂的操作，应该在操作开始前写上若干行注释
对于 不是一目了然的代码，应在其行尾添加注释（为了提高可读性，注释应该至少离开代码 2 个空格）
绝不要描述代码，假设阅读代码的人比你更懂 Python，他只是不知道你的代码要做什么

在一些正规的开发团队，通常会有 代码审核 的惯例，就是一个团队中彼此阅读对方的代码

关于代码规范

Python 官方提供有一系列 PEP（Python Enhancement Proposals）文档
其中第 8 篇文档专门针对 Python 的代码格式 给出了建议，也就是俗称的 PEP 8
文档地址：https://www.python.org/dev/peps/pep-0008/
谷歌有对应的中文文档：http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

2. 运算符

同java类似，如下

算数运算符

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

In [1]: "-" * 50
Out[1]: '----------------------------------------'

3. 变量

1. 变量的类型

在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为 数字型 和 非数字型
数字型
- 整型 (int)
- 浮点型（float）
- 布尔型（bool）
  - 真 True 非 0 数 —— 非零即真 计算时对应的数字为1
  - 假 False 0
- 复数型 (complex)
  - 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
非数字型
- 字符串
- 列表
- 元组
- 字典
使用 type 函数可以查看一个变量的类型

2. 不同类型变量之间的计算

数字型变量 之间可以直接计算

在 Python 中，两个数字型变量是可以直接进行算数运算的
如果变量是 bool 型，在计算时
- True 对应的数字是 1
- False 对应的数字是 0

字符串变量 之间使用 + 拼接字符串

在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

字符串变量 可以和整数使用 * 重复拼接相同的字符串
数字型变量 和 字符串 之间 不能进行其他计算

如何拼接字符串和数字，打印到一行？ print(“hello %d”%i)

3. 变量的命名

同java

4. 循环

while循环

count = 0
i = 0
while i<=100:
    count+=i
    i+=1
print(count)

break和continue同java

for循环

在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历

使用 for 就能够实现迭代遍历

for 变量 in 集合:
    
    循环体代码
else:
    没有通过 break 退出循环，循环结束后，会执行的代码

6. 函数

1. 概念

一个 提前准备好的功能(别人或者自己写的代码)，可以直接使用，而 不用关心内部的细节

目前已经学习过的函数

函数	说明
print(x)	将 x 输出到控制台
type(x)	查看 x 的变量类型
input(x)	键盘输入

2. 函数的定义

格式

def 函数名():  # def 是define的缩写

    函数封装的代码
    ……

3. 函数的调用

通过函数名()即可完成对函数的调用

def say_hello():
    name = "小明"
    i = 0
    while(i<3):
        print("hello %s第%d次见到你很高兴"%(name,i))
        i+=1

say_hello()

4. 函数的返回值

同java，用return

def measure():
    """返回当前的温度"""
    
    print("开始测量...")
    temp = 39
    print("测量结束...")
    
    return temp

result = measure()
print(result)

在利用元组在返回温度的同时，也能够返回湿度

def measure():
    """返回当前的温度"""

    print("开始测量...")
    temp = 39
    wetness = 10
    print("测量结束...")

    return (temp, wetness)
  # 提示：如果一个函数返回的是元组，括号可以省略 return temp,wetness

技巧

在 Python 中，可以 将一个元组 使用 赋值语句 同时赋值给 多个变量
注意：变量的数量需要和元组中的元素数量保持一致

result = temp, wetness = measure()

面试题 —— 交换两个数字

a,b = b,a  # 利用元祖，python特有

5. 缺省参数

具有默认值的函数参数，就是缺省参数 default，简化函数的调用

缺省参数的注意事项

1) 缺省参数的定义位置

必须保证 带有默认值的缺省参数 在参数列表末尾

2) 调用带有多个缺省参数的函数

在 调用函数时，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！

6 多值参数

定义支持多值参数的函数

有时可能需要 一个函数 能够处理的参数个数是不确定的，这个时候，就可以使用 多值参数
python 中有两种多值参数：
- 参数名前增加一个 * 可以接收元组
- 参数名前增加两个 * 可以接收字典
一般在给多值参数命名时，习惯使用以下两个名字
- *args —— 存放元组参数，前面有一个 *
- **kwargs —— 存放字典参数，前面有两个 *
args 是 arguments 的缩写，有变量的含义
kw 是 keyword 的缩写，kwargs 可以记忆 键值对参数

def demo(num, *args,**kwargs):
    print(num)
    print(args)
    print(kwargs)

demo(1,2,3,4,name="小明",age=18,gender=True)
'''
1
(2, 3, 4)
{'name': '小明', 'age': 18, 'gender': True}
'''

案例：

def sum_num(*args):
    sum=0
    for n in args:
        sum+=n

    return sum

print(sum_num(1,2,3,4,5))

元组和字典的拆包

在调用带有多值参数的函数时，如果希望：

- 将一个 元组变量，直接传递给 args
- 将一个 字典变量，直接传递给 kwargs
就可以使用拆包，简化参数的传递，拆包的方式是：
- 在 元组变量前，增加一个 *
- 在 字典变量前，增加两个 *

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

# 需要将一个元祖变量/字典变量传递给函数对应的参数
gl_nums = (1,2,3)
gl_xiaoming = {"name":"小明","age":18}

# 把num_tuple 和xiaoming 作为元祖传递给args
demo(*gl_nums,**gl_xiaoming)

7. 函数的递归

函数调用自身的 编程技巧 称为递归

def sum_numbers(num):
    print(num)
    # 递归的出口
    if num==1:
        return

    sum_numbers(num-1)

sum_numbers(3)

案例

def sum_numbers(num):
    if num==1:
        return 1

    # 假设sum_numbers能够完成num-1的累加
    temp = sum_numbers(num-1)

    # 函数内部的核心算法：两个数字的相加
    return num+temp

print(sum_numbers(100))

4. 导包

复用其他模块

7. 高级变量类型

1. 列表

1. 定义

List，也就是java的数组

专门用于存储 一串信息
列表用 [] 定义，数据之间使用 , 分隔
列表的索引从 0 开始
- 索引就是数据在列表中的位置编号，索引又可以被称为下标

注意：从列表中取值时，如果 超出索引范围，程序会报错

2. 常用操作

列表.append(数据) 末尾增加数据
列表.extend(列表2) 将列表2 的数据追加到列表1后面
列表[索引]=数据 修改指定索引的数据
del 列表[索引] 删除指定索引的数据
列表.remove[数据] 删除第一个出现的指定数据
列表.pop 删除末尾数据
列表.pop(索引) 删除指定索引数据
列表.clear 清空列表
len(列表) 统计列表长度
列表.count(数据) 数据在列表中出现的次数
列表.sort() 升序排序
列表.sort(reverse=True) 降序排序
列表.reverse() 逆序、反转

list1 = [1,2,3,4,5]
list2 = [1,2,3,4,5]
# list1.append(6)
# list1.extend(list2)
# list1[0] = 3
# del list1
# list1.remove(1)
# list1.pop()
# list1.pop(1)
# list1.clear()
# list1.sort(reverse=True)
list1.reverse()
print(list1)

2. 元祖

1. 定义

Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

元组表示多个元素组成的序列
元组在 Python 开发中，有特定的应用场景
用于存储 一串信息，数据之间使用 , 分隔
元组用 () 定义
元组的索引从 0 开始

info_tuple = ("zhangsan", 18, 1.75)

创建空元组

info_tuple = ()

元组中 只包含一个元素 时，需要 在元素后面添加逗号

info_tuple = (50, )

2. 常用操作

元祖[索引] 从列表中取值
元祖.index(数据) 获取数据第一次出现的索引值
len(元祖) 获取元祖的长度 n+1
元祖.count(数据) 数据在元祖中出现的次数
tuple(列表) 将列表转换为元祖 list(元祖) 将元祖转换为列表

info_tuple = (1,2,3,4,5,2)
# print(info_tuple[0])
print(len(info_tuple))
print(info_tuple.index(2))
print(info_tuple.count(3))

3. 字典

1. 定义

dictionary（字典）是 除列表以外 Python 之中 最灵活 的数据类型，类似java的map集合

字典同样可以用来 存储多个数据
- 通常用于存储 描述一个 物体 的相关信息
和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合
字典用 {} 定义
字典使用 键值对 存储数据，键值对之间使用 , 分隔
- 键 key 是索引
- 值 value 是数据
- 键和值之间使用 : 分隔
- 键必须是唯一的
- 值可以取任何数据类型，但键只能使用 字符串、数字或元组
在 Python 中，设置字典的 键值对 时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查
- 键值对的 key 必须是不可变类型数据
- 键值对的 value 可以是任意类型的数据

xiaoming = {
    "name":"小明",
    "age":18,
    "gender":True,
    "height":1.75
}

2. 常用操作

len(字典) 获取字典的键值对数量
字典.keys() 所有key列表
字典.values() 所有value列表
字典.items() 所有(key,value) 元祖列表
字典[key] 可以从字典中取值，key不存在会报错
字典.get(key) 可以从字典汇总取值，key不存在不会报错
字典[key] = value 如果key存在，修改数据；如果key不存在，新建键值对
字典.setdefault(key,value) 如果key存在，不会修改数据；如果key不存在，新建键值对
字典.update(字典2) 将字典2的数据合并到字典1
del 字典[key] 删除指定键值对，key不存在会报错
字典.pop(key) 删除指定键值对，key不存在会报错
字典.popitem() 随机删除一个键值对
字典.clear() 清空字典

xiaoming = {
    "name":"小明",
    "age":18,
    "gender":True,
    "height":1.75
}

# print(len(xiaoming))
# print(xiaoming.keys())
# print(xiaoming.values())
# print(xiaoming.items())
# print(xiaoming["name"])
# print(xiaoming.get("weight"))
# xiaoming["name"] = "大明"
# print(xiaoming.items())
# xiaoming.setdefault("weight",72)
# print(xiaoming.items())
xiaoming.update(xiaoming)
# print(xiaoming)
# del xiaoming["height"]
# print(xiaoming.items())
# xiaoming.pop("height")
print(xiaoming.items())
xiaoming.popitem()
print(xiaoming.items())
xiaoming.clear()
print(xiaoming.items())

4. 字符串

1. 定义

字符串 就是 一串字符，是编程语言中表示文本的数据类型

在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串
- 虽然可以使用 \" 或者 \' 做字符串的转义，但是在实际开发中：
  - 如果字符串内部需要使用 "，可以使用 ' 定义字符串
  - 如果字符串内部需要使用 '，可以使用 " 定义字符串
可以使用索引获取一个字符串中 指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历 字符串中每一个字符

大多数编程语言都是用 " 来定义字符串

2. 常用操作

太多了，在pycharm中可以查看

1) 判断类型 - 9

方法	说明
string.isspace()	如果 string 中只包含空格，则返回 True
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True，`全角数字`
string.isdigit()	如果 string 只包含数字则返回 True，`全角数字`、`⑴`、`\u00b2`
string.isnumeric()	如果 string 只包含数字则返回 True，`全角数字`，`汉字数字`
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

2) 查找和替换 - 7

方法	说明
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 `-1`
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

3) 大小写转换 - 5

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.swapcase()	翻转 string 中的大小写

4) 文本对齐 - 3

方法	说明
string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width)	返回一个原字符串居中，并使用空格填充至长度 width 的新字符串

5) 去除空白字符 - 3

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

6) 拆分和连接 - 5

方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
string.splitlines()	按照行(’\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

hello_str = " woaini zhognguo qinaide muqin "
# 判断类型
# print(hello_str.isspace())
# print(hello_str.isalnum())
# print(hello_str.isalpha())
# print(hello_str.isdecimal())
# print(hello_str.isdigit())
# print(hello_str.isnumeric())
# print(hello_str.istitle())
# print(hello_str.islower())
# print(hello_str.isupper())
# 查找和替换
# print(hello_str.startswith("a"))
# print(hello_str.endswith("b"))
# print(hello_str.find("wo"))
# print(hello_str.rfind("wo"))
# print(hello_str.index("ai"))
# print(hello_str.rindex("ai"))
# print(hello_str.replace("wo","xiaoming"))

# 大小写转换
# print(hello_str.capitalize())
# print(hello_str.title())
print(hello_str.lower())
# print(hello_str.upper())
# print(hello_str.swapcase())
# print(hello_str.ljust(1))
# print(hello_str.center(2))
# 去除空白字符
# print(hello_str.lstrip())
# print(hello_str.rsplit())  # ['woaini', 'zhognguo', 'qinaide', 'muqin']
# print(hello_str.strip())
# 拆分和连接
# print(hello_str.partition("ai")) # (' wo', 'ai', 'ni zhognguo qinaide muqin ')
# print(hello_str.rpartition("ai"))  # (' woaini zhognguo qin', 'ai', 'de muqin ')
# print(hello_str.split(" ",3))  # ['', 'woaini', 'zhognguo', 'qinaide muqin ']
# print(hello_str.splitlines())  # [' woaini zhognguo qinaide muqin ']
# print(hello_str.join("a,b,c"))
# 效果：a woaini zhognguo qinaide muqin , woaini zhognguo qinaide muqin b woaini zhognguo qinaide muqin , woaini zhognguo qinaide muqin c

7）字符串的切片

切片方法适用于 字符串、列表、元组
- 切片使用 索引值 来限定范围，从一个大的 字符串 中切出小的 字符串
- 列表和元组都是有序的集合，都能够 通过索引值 获取到对应的数据
- 字典是一个无序的集合，是使用 键值对 保存数据

字符串[开始索引:结束索引:步长]

注意：

指定的区间属于 左闭右开 型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
- 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字可以省略，冒号不能省略
步长默认为 1，如果连续切片，数字和冒号都可以省略

8）索引的顺序和倒序

在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
所谓倒序索引就是 从右向左 计算索引
- 最右边的索引值是 -1，依次递减

num_str = "0123456789"
# 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6]) #  2345
# 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])  # 23456789
# 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])  # 012345
# 截取完整的字符串
print(num_str[:])
# 从开始位置，每隔一个字符截取字符串
print(num_str[::2])  # 02468
# 从索引 1 开始，每隔一个取一个
print(num_str[1::2])  # 13579
# 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])  # 2345678
# 截取字符串末尾两个字符
print(num_str[-2:])  # 89
# 字符串的逆序（面试题）
print(num_str[::-1])  # 9876543210

8. 公共方法

1. python内置函数

Python 包含了以下内置函数：

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函数

注意

字符串 比较符合以下规则： “0” < “A” < “a” ASCII码 48 65 97

2. 运算符

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[“Hi!”] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 3) < (2, 2, 3)	True	元素比较	字符串、列表、元组

注意

in 在对字典操作时，判断的是 字典的键
in 和 not in 被称为 成员运算符

成员运算符

成员运算符用于测试序列中是否包含指定的成员

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	`3 in (1, 2, 3)` 返回 `True`
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	`3 not in (1, 2, 3)` 返回 `False`

注意：在对字典操作时，判断的是 字典的键