python语言的特点

1、在python中无{}的概念，代码采用缩进的方式来表达范围

2、python语言是弱类型语言，在变量定义的时候无需指定类型

3、python语言不使用分号结尾，在java中每行语句必须以分号结尾

4、python是解释型语言，无序编译

python语法

python的数据类型

python中有6中数据类型，如下表所示

|----------------|----------------------------------|--------------------------------------------|
| 类型 | 描述 | 说明 |
| 数字（Number） | 支持整数int、浮点数float、复数complex布尔bool | 复数：4+3j 以j结尾表示复数 bool：true记为数字1，false记为数字0 |
| 字符串（String） | 描述文本的一种数据类型 | 字符串由任意数量的字符组成 |
| 列表（List） | 有序的可变序列（类似java List集合） | 记录一堆数据，在python中频繁使用 |
| 元组（Tuple） | 有序的不可变序列（类似java数组） | 记录一堆不可变的python数据集合 |
| 集合（Set） | 无序不重复集合（类似java set） | 记录一堆不重复的python数据集合 |
| 字典（Dictionary） | 无序key-value结构（类似java map） | 记录一堆无序的key-value python数据集合 |

在python中使用type()方法来判断类型

python 复制代码

a = "ceshi"

print(type(a))

# 输出结果 <class 'str'>

数据转换

|----------|------------|
| 语句 | 说明 |
| int(x) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| str(x) | 将对象x转换为字符串 |

python中的注释

单行注释

"""

123

"""

三引号则是多行注释

python 复制代码

# 测试数据
a = "ceshi"
"""
    123
    456
"""
print(type(a))

python的if语句

python的条件判断语句最大的不同就是判断多了个关键字elif 以及语法格式上的不同

if xxx:

xxx

elif xxx:

xxx

else:

xxx

python 复制代码

a = 175

if a <100:
    print("金额小于100")
elif a > 300:
    print("金额大于300")
else:
    print(f"金额为{a}")

python的循环语句

while循环

python 复制代码

i = 1

while i < 101:
    print(f"我要敲代码{i}次")
    i += 1

for循环：依次一个个取出

for x in [字符串｜列表｜元组]：

print("111")

python 复制代码

message = "I like study python"

for x in message:
    print(x)

range语句

可以通过range语句界定范围，语法格式如下【左闭右开形式的】

range(num2), // 代表从0开始到num2结束，step为1，不包含num2的序列

range (num1,num2) // 代表从num1开始取到num2结束的序列，不包含num2

range (num1,num2,step),// // 代表从num1开始取到num2结束的序列，不包含num2,step为步长，默认为1

python 复制代码

for x in range(10):
    print(x)

for x in range(5,10):
    print(x)

for x in  range(0,10,2):
    print(x)

python循环语句的continue和break和java等语言类似，continue是跳过本次循环，break是终止循环，这里不做演示

python的字符串

三种定义方式：

单引号定义： name = 'python'

双引号定义： name = "python"

三引号定义： name = """python"""

注意：三引号定义和多行注释一样，同样支持换行操作，使用变量接收，它就是字符串，不使用变量接收，它就是多行注释
字符串拼接

1: +号拼接，无法和非字符串类型拼接

2:字符串格式化 % 占位

3: 快速格式化写法 f 用此方法居多

python 复制代码

#字符串定义
a = "ceshi"
b = "python"
# 字符串拼接 不能拼接非字符串类型变量
print(a+b)
# 字符串格式化写法 % 表示占位 s 将变量放入占位的地方
print("测试数据 %s" % b)
# 字符串格式化快速写法 f 此方式不理会类型 不做精度控制
print(f"{a},{b}")

#可以格式化表达式
print(f"9 * 9={9*9}")

input()函数读取用户输入的字符串

python 复制代码

print("请输入你的名字：")

name = input()

print(f"你的名字是{name}")

字符串的分隔

字符串.split(分隔字符串) // 将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

python 复制代码

message = "I like study python"

split_result = message.split(" ")

print(f"message分隔之后：{split_result}")

#结果为 message分隔之后：['I', 'like', 'study', 'python']

python的列表

python列表是一个数据容器，可以添加任意数据类型，列表还有其他方法，这里不介绍过多

python 复制代码

name_list = ["zhangsan","lisi","wangwu",3]

#追加一个新元素
name_list.append(32)
#追加一个列表
name_list.extend([12,13,11])

print(name_list)
#取第一个元素
print(name_list[0])
#取最后一个元素
print(name_list[-1])
# 循环list
for x in name_list:
    print(x)

"""
输出结果如下：
['zhangsan', 'lisi', 'wangwu', 3, 32, 12, 13, 11]
zhangsan
11
zhangsan
lisi
wangwu
3
32
12
13
11

"""

python的元组

python的元组类似于java的数组，不可变序列

去掉修改的操作，不可变，如果变的话会报错

定义方式：

变量 = （"hello",）// 元组只有一个元素时，必须带逗号，否则不是元组类型，而是Str类型

变量 = tuple(["zhangsan","lisi","wangwu",4])

python 复制代码

name_list =("zhangsan","lisi","wangwu",4,)

#name_list = tuple(["zhangsan","lisi","wangwu",4])

print(name_list)
#取第一个元素
print(name_list[0])
#取最后一个元素
print(name_list[-1])
# 循环list
for x in name_list:
    print(x)

"""
输出结果：
('zhangsan', 'lisi', 'wangwu', 4)
zhangsan
4
zhangsan
lisi
wangwu
4
"""

python的set集合

python的set集合无序的，不重复的，所以集合不支持索引访问，但允许修改,类似java 的单列集合Set

python 复制代码

my_set ={"zhangsan","lisi","lisi",2}

print(type(my_set))

my_set.add("wangwu")
# 循环set
for x in my_set:
    print(x)

"""
输出结果：
<class 'set'>
lisi
wangwu
2
zhangsan
4

"""

python的字典

python中的字典类似于java中的map，类似于双列集合，key-value结构,无索引访问，通过key取value

python 复制代码

my_dict = {"shilei": "like", "xiaoyue":"you"}
my_dict_1 = {
    "key1":{
        "name":"lisi",
        "age":3
    },
    "key2": {
        "name": "zhangsan4",
        "age": 4
    }
}
print(type(my_dict))

# 循环my_dict
for x in my_dict:
    print(my_dict[x])


# 循环my_dict_1
for x in my_dict_1:
    print(my_dict_1[x])

python的序列切片

序列支持切片，即:列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[开始下标:结束下标:步长] // 从开始位置开始，依次取出元素，到指定位置结束得倒一个新序列

步长：

步长1表示，一个个取

步长2表示，每次跳过一个取

步长为负数表示，反向取(注意，开始位置和结束下标也要反向标)

开始结束不写代表从头到尾，步长为1可以省略

python 复制代码

# 对元组切片
my_tuple = (1,2,3,4,5,6)

result = my_tuple[:]

print(f"结果为{result}")

#对str切片
my_str = "123456"

result1 = my_str[::2]

result2 = my_str[::-1]


print(f"结果为{result1}")

print(f"结果为{result2}")

#对list切片
my_list = [0,1,2,3,4,5,6]

result3 = my_list[3:1:-1]

print(f"结果为{result3}")

输出结果为：

python 复制代码

结果为(1, 2, 3, 4, 5, 6)
结果为135
结果为654321
结果为[3, 2]

python的函数

函数的定义关键字def 中，函数的返回值用rerun，python中可以返回多个值，如果没有return，在python中也会返回，返回None，None作为一个特殊的字面量，用于表示空、无意义，用在函数无返回值上

用在if判断上：

在if判断中，None等同于false

一般用于在函数中主动返回None，配合if判断做相关处理

python 复制代码

def add(a,b):
    return a+b;

r = add(1,2)

print(r)

#3

多返回值函数

python 复制代码

# 定义多个返回值函数
def multi(a,b):
    return a+b,a,b;

r ,c , v= multi(1,2)

print(r,c,v)

缺省参数_

python 复制代码

# 定义多个返回值函数
def multi(a,b):
    return a+b,a,b;
# 缺省参数
r ,_ , v= multi(1,2)

print(r,v)

默认参数，默认参数只写在参数最后位置上

python 复制代码

# 默认参数
def default(a,b,c="default param"):
    print(a,b,c)

default(1,2)
default(2,3,4)


"""
输出结果
1 2 default param
2 3 4
"""

函数可变参数，*args：接收N个位置参数，转换成元组tuple形式，**kwargs，以字典的形式接受参数

python 复制代码

# 默认参数
def change(*args):
    print(args)
#以字典的形式接收参数
def change_dict(**kwargs):
    print(kwargs)

change(1,2,3)

change_dict(name = "name",age="3")


change(1,2,3)

"""
输出结果
(1, 2, 3)
{'name': 'name', 'age': '3'}
"""

关键字参数，函数调用时通过"键=值"键值对的形式传递参数，不用遵循形参的顺序

python 复制代码

# 默认参数
def add(a,b,c):
    print(a,b,c)

add(b="2",a="5",c="4")

"""
输出结果
5 2 4
"""

lambda关键字 ，可以定义匿名函数（无名称）

特点：

def关键，定义有名称的函数，可重复使用，匿名函数只临时调用一次，类似于java的lambda

定义语法：lambda 传入参数：函数体(只能写一行代码，不支持多行)

python 复制代码

#普通定义方式
def func(add):
    x=add(1,2)
    print(x)

def add(a,b):
    return a+b

func(add)

#lambda方式

func(lambda x,y:x+y)

if main== "main"主入口 ， __main__是python的内置变量，如果作为程序直接执行是条件成立，为true，如果是作为模块导入，则无法成立，不会执行

python的包与模块

包：从物理上看包就是一个文件夹，包含好多模块，但是包下必须包含一个__init__.py文件，作为包的标识，从逻辑上看，包的本质依然是模块

模块: 一个模块就是一个以.py结尾的python文件，常用导入组合形式：

import 模块名

from 模块名 import 类、变量、方法等

from 模块 import *

import 模块名 as 别名

from 模块名 import 功能名 as 别名

在python的生态中，有许多非常多的第三方包(非python官方，可以极大的提高开发效率)

科学计算中常用的：numpy包

数据分析中常用的：pandas包

大数据计算中常用的:pyspark包、apache-flink包

图形可视化常用的：matplotlib、pyecharts

人工智能常用的：tenssorflow等，没有安装它们才可以导入

pip install 包名称安装可以通过加速器加速安装

国内常用源镜像地址：

清华：https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：http://pypi.hustunique.com/

pip install numpy -i http://mirrors.aliyun.com/pypi/simple/
查看哪些包已经安装过啦

模块引入

python 复制代码

#导入time模块
import time

print("开始")
time.sleep(2)
print("结束")

自定义模块,新建文件夹MyDefine

python 复制代码

def add(a,b):
    print(a+b)

在自己模块中调用，注意，如果同名功能，下边的会覆盖上边的

python 复制代码

import myDefine

myDefine.add(1,2)

"""
输出3
"""

all 变量可以控制import *的时候哪些功能可以被导入,MyDefine定义的add，在被引入的时候，没有规定的变量编译器会报错

python 复制代码

__all__ = ["add"]

def add(a,b):
    print(a+b)

def muti(a,b):
    print(a*b)

python基础语法

python语言的特点

python语法

python的数据类型

单行注释

python的if语句

python的循环语句

python的字符串

python的列表

python的元组

python的set集合

python的字典

python的序列切片

python的函数

python的包与模块