python学习笔记：基础语法

目录

python语言概述

python基础语法

python标准数据类型

1.数字类型

 2.字符串类型

3.列表类型

 4.元组

 5.字典

python基础语法

1.条件判断语句

2.循环语句 

 3.函数

 4.全局变量和局部变量

---

python语言概述

 

        python是一种解释型的语言，这意味着开发过程中没有了编译这个环节，和C的shell类似，是一种交互性语言，是一种面向对象的语言，这表示python支持面向对象的风格或代码封装在对象的编程技术，是一种初学者的语言，它支持广泛的应用程序开发，从简单的文字处理到WWW浏览器和游戏，常用于人工智能，web应用，爬虫程序，大数据等方面。

python基础语法

1.注释

单行注释，以#开头

多行注释，以'''开头，'''结尾

注意：使用缩进取代逻辑或者函数后面{}包含内容，所有内部代码缩进必须相同

2.输出print

print(*values，sep=' ',end='\n',file=sys.stdout,flush=False)
values:要打印的值
sep:表示要输入多个打印的值时，各个值之间分割方式，默认空格间隔
end:控制print传入值输出完后结束符号，默认换行
file:设置输出对象，即把print中的值打印到什么地方

基本用法代码示例：

a = 12
b = 'abc'
c = "hello"

print(a, b, c)
print("a: ", a)
print("b: ", b, "c: ", c)
# 使用格式化控制符
print("a: %d" % a)
print("b: %s c: %s " % (b, c))

# 像QString的arg方法,使用字符串的format方法
print("a : {} b: {} c: {}".format(a, b, c))
print("a : {2} b: {1} c: {0}".format(a, b, c))

# 修改print函数的默认参数,去除多数值简答的间隔
print(a, b, c, sep="")

 运行结果如上

3.输入--input（）

input接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型并且只能输入一个

用法代码示例：

 a = input()
 a = input("请输入： ")
 print(a)
 type():返回a的类型
 print("a type is", type(a))

 b = int(input("请输入： "))  # int() 类型强制转换
 print(b)
 print("b type is", type(b))
 input不能进行多个输入，将所有输入默认为字符串处理，并返回字符串

4.变量赋值

    1.变量赋值，用=（注意加空格）
    2.多变量同时赋值一个类型的数值
            a = b = c = 1
    3.多变量同时赋值不同类型的赋值
            a, b, c =1, "hello", 2

注意：和C语言不一样，在python中变量更像是附在对象上的标签（和引用类似）。当变量被绑定在一个对象上时，该变量的引用计数就是1，系统会定时扫描，当某个标签应勇计数为0，该对象就会被系统回收。

看看代码进行理解把：

a, b, c = 1, "hello", 2
print(a, b, c)

a = b = c = 1  # 为数值1 开辟空间，再给空间取别名为 a,b,c
print(a, b, c)
# id() :求变量地址
print(id(a), id(b), id(c))

b = 3
print(id(a), id(b))a, b, c = 1, "hello", 2
print(a, b, c)

        从运行结果可以验证我们上述的说法，当我们对多变量赋值相同时，打印他们的地址会发现这些变量的地址都是相同的。 

python标准数据类型

（1）数字类型 Number:可以是整数，浮点，复数complex等数据
（2）字符串类型 Str/bytes：文本字符串/字节字符串
（3）列表类型 List : 使用【】进行表示，列表元素可变
（4）元组类型 Tuple：使用（）进行标识，元组元素只可读
（5）字典类型  dict:使用{}进行标识 key:vlaue 键值对，字典元素值可变

数据类型分为不可变类型（数字，字符串，元组（），不可变集合）和可变类型（列表【】，字典 {}，可变集合）

不可变类型：不支持原处修改
可变类型：可以通过操作原处修改，而不用创建新的对象

1.数字类型

整型（int）通常用0b 0o 0x分别表示二进制，8进制，16进制，浮点型通常由整数部分和小数部分组成，复数由实数部分和虚数部分，可以用a+bj或者complex(a,b)表示，实部和虚部都为浮点型

# 导入math库中的ceil函数 floor函数，到当前脚本中
from math import ceil, floor
a = -5
print(abs(a))  # abs:求绝对值
b = 2.8
print(ceil(b))  # ceil():向上取整
print(floor(b))  # floor():向下取整

# 从random随机数的库中，导入randrange函数
from random import randrange, randint, uniform
# randrange([start],stop, [step]): 开始，结束，步长，必须满足左闭右开
c = randrange(1, 5, 2)  # 产生随机数
print("c: ", c)

d = randint(1, 6)  # 产生随机的整数，无步长限制
print("d: ", d)

e = uniform(0, 1)  # 产生随机的浮点数（0，1）
print("e: ", e)

 数字类型转换：

int(x):将x转换为一个整数

float(x)：将x转换到一个浮点数

complex(x)：将x转换到一个复数，实数部分为x,虚数部分为0

complex(x,y)：将x和y转换到一个复数，实数部分为x,虚数部分为y.

数学函数：

 随机函数

 2.字符串类型

python语言有两种不同的字符串

1.string:一个用于存储文本（字符），文本字符串内部使用unicode存储

2.bytes:一个用于存储原始字节（二进制），字节字符串存储原始字节并显示ASCII

.字符串中的切片
切片是指对操作对象截取其中一部分的操作，语法：【起始：结束：步长】左闭右开

"""
1.str: 字符串类型，用于存储文本数据，也就是字符
2.bytes:字符串类型，用于存储字节数据，也就是二进制
"""
text_str = "hello world"
byte_str = b"hello world"
print(type(text_str), type(byte_str))
print(text_str, byte_str)

'''
 字符串数据的访问：【i】
'''
print(text_str[4])
"""
 字符串的切片:[start:stop:step] 左闭右开，默认步长为1
"""
text_str = "hello world"
print(text_str[2: 5])
print(text_str[: 3])  # 默认从0下标开始
print(text_str[: -1])  # 从下标0开始，-1最后一个元素下标
print(text_str[:: 2])  # 从头到尾，步长为2

字符串的运算 ：+表示字符串的拼接

"""
字符串的运算：
    1. +:字符串的拼接
    2. *n:字符串重复n次
"""
print(text_str + "welcome")
print(text_str*3)
"""
字符串函数
    1.len:求字符串长度
    2.find:检测子串
    3.index:和find一样
    4.count:返回字符串在start和end之间在另一个字符串里出现的次数
    5.replace:把字符串中的子串替换成新的字符串
"""
print(len(text_str))

3.列表类型

定义格式：列表名字 = 【元素1，元素2，...............】

元素可以是任意类型的，字符，数字，字符串，列表等等

元素获取通过下标来进行索引

list1 = [1, 2, "one"]
list2 = [1, 2, "one", [1, 3, "two"], list1]

print(list1[0], list1[2])
print(list1[2][2])
print(list2[3][2])

 列表元素也可以进行切片：

"""
    列表元素可以切片
"""
print(list2[1: 4])

看看结果：

对列表元素进行修改：

"""
    列表元素的修改
"""
list1[1] = 234
list1[2] = "three"
print(list1)

看看结果：

 列表的一些常用函数：

list3 = []
for i in range(10):
    list3.append(i)   # 向列表末尾追加元素
print(list3)

list3.insert(3, 120)   # 向列表中3这个下标插入元素 120
list3.insert(3, "three")
print(list3)

list4 = [5, 4, 3, 2, 1]
list4.sort()     # 将列表中的元素进行排序,默认升序
print(list4)

print(max(list4))  # 求列表中的最大值

看看运行结果：

 列表的运算：

"""
    列表的运算
"""
# []+[] 将两个列表相加就是将两个列表元素进行拼接，形成新的列表
print([1, 2, 4] + [4, 5, 6])
# 【】* n ,就是将列表元素重复n次，拼接成新的列表
print([1, 2, 3] * 3)

接下来我用一张图总结一下列表的相关函数：

 4.元组

        元组类似于list，用（）标识，内部元素用逗号隔开，但是元组不能进行而二次赋值，也就是不可修改，相当于只读列表。

"""
元组tuple类型，（）标识，元素值不可变，使用方式和list一样
"""
# t = () 定义一个空的元组，但是没有任何意义，因为元组元素不能修改
t = (1, 3, "one", [3, 4], ([1, 2], "two"))
print(t)
print(t[2])
print(t[3][1])
print(t[4][0][1])

# t[0]=2 错误 元组元素不能修改
# t[2][1]= "3"  字符串元素不能修改
t[3][0] = 2 # 列表可以修改
print(t)

 5.字典

1.无序的对象集合

2.用“{ }”标识

3.字典由索引key和他对应的值value组成，key可以是数字类型也可以是字符串类型，value可以是任意类型。

4.字典元素的访问 【key】

"""
    字典dict类型， {key:value ， key:value}标识
    元素为键值对
    key只能是number 或 str类型
    value:可以是任意的类型
"""
# dic = {}  # 定义一个空字典
dic = {1: "one", "two": 2, 3: [1, 2, 3], "for": {1: "one", 2: "two"}}
print(dic)

"""
    字典元素的访问 【key】
"""
print(dic[1])
print(dic["two"])
print(dic[3][1])

"""
    字典元素的修改
"""
dic[1] = "three"
print(dic)

"""
    字典元素的新增：【newKey】=value
"""
dic["new"] = 1234
print(dic)

python基础语法

1.条件判断语句

"""
注意结构语句：用：和缩进代替{}结构，相同缩进的代码行处于同一个结构中
1.判断语句
    if 表达式：
        结构语句
    elif 表达式：
        结构语句
    else:
        结构语句

a, b = 23, 25
if a > b:
    print("a is max")
else:
    print("b is max")
print("b is max")

2.循环语句 

for 循环：
    for 变量 in 单词表：
        结构语句
    表示每循环一次，变量就取单词表中的一个数据
    1.单词表可以是多个任意类型的数据组成，数据之间用逗号隔开
    2.单词 表也可以是一片连续的数字类型，用range()生成
    3.单词表可以是 列表类型，每循环一次，变量取列表中的一个元素

for i in 1, 25, "one", [1, 2, 3], (3, 2), {1: 2}:
    print(i, end=" ")
print()

for i in range(10):
    print(i, end=" ")
print()

for i in [1, 2, 3, 4, 5, 6, 7]:
    print(i, end=" ")
print()
"""
    while循环
    python中没有i++ ,i--
"""
i = 0
while i < 10:
    print(i, end=" ")
    i += 1
print()

 3.函数

def 函数名（形参列表）
    函数体
    return
def为函数说明的关键字
形参列表中，可以有一个，多个或者没有参数，多个参数以逗号隔开
参数：说明函数时，形参没有数据类型，当调用时根据实参的类型来决定
函数可以有返回值，可以同时返回多个数据，返回值可以是任意类型

# 函数的说明
def add(x):
    print("type: ", type(x))
    return x + 1
# 函数的调用
res = add(3)
print(res)

# 返回多个数值，以逗号隔开，调用时就需要定义多个变量来保存相应的返回值
def add(x, y):
    return x + y
print(add(3, 4))
print(add([1, 3], [2, 3]))

def swap(x, y):
    return y, x
x, y = swap(2, 3)
print(x, y)

x, y = swap((1, 3, 4), [4, 5, 6])
print(x, y)

来看看结果：

匿名函数和朗达表达书

匿名函数：lambda表达式
    (lambda a1, a2... : value)(arg1,arg2...)
    注意：
        1.调用匿名函数时，将arg1传递给a1,arg2给a2
        2.该表达式返回value数值
        3.a1,a2代表原函数的形参，多个形参以逗号隔开
        4.value代表原函数的返回值

 

 def func(x):
    return x + 1
a = lambda x: x + 1
print(func(3))
print(a(3))

print((lambda x: x+1)(3))

# def func(x, y):
#    return x + y
print((lambda x, y: x + y)(1, 5))

# print((lambda x, y: y, x)(1, 5)) 错误返回值是元组类型，不能被当成函数调用
# lamdba 表达式不能返回两个数值

 扩展：列表推导式

"""
    列表推导式
"""
# 定义列表，元素为i,而i会随着循环取值，循环多少次，那么i值就有多少个，列表元素就有多少个
list1 = [i for i in range(11)]
print(list1)

# 定义列表，元素j，当每次循环j从单词表中取值，并满足j为偶数时，j才会作为列表元素
list1 = [j for j in range(101) if j % 2 ==0]
print(list1)

# 定义一个列表，将0-11之间数据的两倍写入列表中
list1 = [k*2 for k in range(12)]
print(list1)

内函数和匿名函数的应用

"""
    内函数和匿名函数的应用
"""
list1 = [('d', 1), ('c', 2), ('b', 3), ('a', 4)]
# key:表示排序的依据，lambda表达式中，x代表列表的每个元素，表达式返回x[0]作为排序的条件
list2 = sorted(list1, key=lambda x: x[0])
print(list2)
list2.sort(key=lambda x: x[1])
print(list2)

 

"""
    普通用法
"""
def sq(x):
    return x**2
# map函数，将第二参数的结果作为第一参数的输入，将输出数据的地址返回出来
a = map(sq, [i for i in range(10)])
print(a)
# list()将地址强转为list类型,print打印之后，地址上的数据被清空
print(list(a))

b = map(lambda x: x**2, [i for i in range(10)])
print(list(b))

 4.全局变量和局部变量

a = 5   # 全局变量
def func():
    global a  # 说明该函数中，使用全局变量a
    a = 4   # 局部变量
func()
print(a)