【Python】基本使用

变量的类型

整数 int

浮点数 float

字符串 str

字符串长度

格式化字符串

布尔类型

动态类型

注释

获取输入

浮点数比较

多元赋值

for循环

函数的定义和调用

创建函数/定义函数

调用函数/使用函数

列表

创建列表

切片操作

遍历列表

新增元素

判断元素是否在列表中

删除元素

连接列表

元组

创建元组

指定初始值

下标访问

切片操作

循环遍历

in判断元素是否存在，index获取下标

使用+拼接两个元组

变量的类型

在python中，变量的类型不需要在定义变量的时候显式声明，而是依靠初始化语句，根据初始化的值的类型来进行确定的。如下示例：

输出一个变量的类型

a=10
print(type(a))

输出如下所示：

整数 int

在Python中，int能够表示的数据范围，是“无穷”的，与C++、Java的int不一样。Python的int是可以根据要表示的数据的大小，自动扩容。因此python中，整数只有int类型。

浮点数 float

C++和Java里面的float是四个字节，也叫做“单精度浮点数”，在Python中，float等同于C++和Java中的double。

字符串 str

Python中，使用引号把一系列字符引起来，就构成了字符串，引号用 ‘’ 或 "" 都可以的。

如果字符串内需要包含引号，外面的引号用另一种引号即可

a='123"456"'

字符串长度

获取字符串长度可以通过len（）方法

a='123"456"'
print(len(a))

格式化字符串

当我们希望打印出 a=10 这样的内容，也就是a这个变量的值是可变的。

a=10
print(f"a={a}")

这种语法，叫做“格式化字符串”，使用{}这样的语法，往字符串里嵌入变量或者表达式

布尔类型

只有两种取值 True、False，主要用于逻辑判定，这里与C++不同的是开头字母大写

动态类型

程序运行过程中，变量的类型可能会发生改变

如下代码：

a=10
print(type(a))
a='hello'
print(type(a))
a=True
print(type(a))

结果如下：

一个编程语言，是否是动态类型，只是取决于运行时，类型是否发生改变，不取决于变量定义的时候是否声明类型！

注释

有两种注释方式

第一种：注释行

使用#开头的行都是注释

#这是一行注释

# 开头的注释，一般是写在要注释的代码的上方，也有少数写在代码的右侧

第二种：文档字符串

使用三引号引起来的称为“文档字符串”，也可以视为是一种注释。

可以包含多行内容
一般放在文件/函数/类的开头
""" 或者 "" 均可（等价）

"""
这是一段文档字符串
这是一段文档字符串
"""

获取输入

num=input("请输入一个整数：")
print(f"输入的整数是：{num}")

input的返回值，是一个str ，如果要对这个读取的str进行算术运算，可以通过int（）进行转换

整数转字符串str（）

字符串转浮点数float（）

浮点数比较

在python中浮点数直接进行比较的话，可能不会返回正确的结果。

a=0.1
b=0.2
print(a+b==0.3)

例如上述的代码返回的结果是false,因为浮点数在内存中的存储和表示，是可能存在误差的，这样的误差在进行算术运算的时候就可能被放大，从而导致 == 的判定出现误判

print(a+b)
print(0.3)

我们可以输出a+b的结果和0.3进行对比，如下：

0.30000000000000004
0.3

因此我们可以通过两个数的差是否在误差范围之内，判断两个数是否相等

print(-0.000001<(a+b-0.3)<0.000001)

上述返回的结果是true

多元赋值

a,b=10,20
print(a)
print(b)

上述代码将10赋值给a，20赋值给b。

多元赋值还可用在交换两个数的值

a,b=10,20

a,b=b,a
print(a)
print(b)

需要注意的是，python中不支持++、--的自增自减操作

for循环

基本语法格式

for 循环变量 in 可迭代对象：

循环体

python的for和其他语言不同，没有初始化语句，循环条件判断语句，循环变量更新语句，而是更加简单。
所谓的可迭代对象，只的是内部包含多个元素，能一个一个把元素取出来的特殊变量。

代码示例：打印1-10

for i in range(1,11) :

print(i)

使用range函数，能够生成一个可迭代对象，生成的范围是[1,11)，左闭右开

代码示例：打印2、4、6、8、10

for i in range(2,12,2)

print(i)

range还提供第三个参数，表示“步长”默认的步长是1，这个步长可以是整数也可以是负数

shift+F6可以针对变量进行重命名，会自动的把所有要修改的名字都替换

函数的定义和调用

创建函数/定义函数

def 函数名（形参列表）：

函数体

return 返回值

调用函数/使用函数

函数名（实参列表） //不考虑返回值

返回值=函数名（实参列表） //考虑返回值

python一个函数可以返回多个值

示例：

def test():
return 1,2,3

x,y,z=test()

在函数内部需要修改全局变量的话，需要引入global关键字

x=10

def test()：

x=20

print(f"x={x}")

如上所示，输出结果是x=10,因为在函数内部x=20,被看作是创建了一个x变量，因此要对全局的x进行修改，需如下所示：

x=10

def test()：

global x

x=20

print(f"x={x}")

for循环不影响变量的作用域,只有函数，类才影响作用域

for i in range(1,11)

print(i)

print(i)

列表

列表和元组类似于其他编程语言中的“数组”

列表和元组之间的区别：

列表是可变的，创建好了之后，随时能改（散装辣条）
元组是不可变的，创建好了之后，改不了，要想改，只能丢弃旧的，搞一个新的（包装辣条）

创建列表

空列表

a=[] a=[1,2,3]

b=list()

c++/java里面要求一个数组里面只能存相同类型的变量，python中列表可以放不同类型的变量

(1) 可以用内建函数len来获取到列表的长度

len(a)

(2) python中的下标，还可以写成负数

例如[-1]等价于[len(a)-1]

切片操作

通过下标操作是以此取出里面第一个元素

通过切片，则是一次取出一组连续的元素，相当于得到一个子列表

使用[ ：]的方式进行切片操作

alist=[1,2,3,4]

print(alist[1:3])

[1:3]表示的是[1,3)这样由下标构成的前闭后开区间
最终结果为2，3

进行切片的时候，可以省略边界

alist=[1,2,3,4]

print(alist[1:])

省略后边界，意思是从开始位置，一直取到整个列表结束
省略前边界，意思是从列表的0号元素开始取，一直取到结束的边界
前后边界都省略掉，得到的就是列表自身

切片操作还可以指定步长

alist=[1,2,3,4]

print(alist[ ::1 ])

1的意思是，每隔一个元素取一个元素
示例：

还可以这样print(alist[ 1：-1：2 ])进行切片
步长的数值还可以是负数，当步长是负数的时候，意思是从后往前遍历元素
当切片中的范围超出有效下标之后，不会出现异常，而是尽可能把符合要求的元素获取到

遍历列表

第一种：不通过下标来访问元素

示例：

a=[1,2,3,4,5]

for elem in a:

print(elem)

这种方式通过elem取出列表元素，对elem修改不会影响到原来的a数组

第二种：通过下标来访问元素

示例：

a=[1,2,3,4,5]

for i in range(0,len(a))

print(a[i])

这种方式通过下标取出列表元素，对elem修改会影响到原来的a数组

新增元素

1、通过append方式往列表末尾新增一个元素

a=[1,2,3,4]

a.append(5)

print(a)

结果如下：

2、还可以使用insert方法，往列表的任意位置来新增元素

a=[1,2,3,4]

a.insert(1,'hello')

print(a)

结果如下：

如果插入下标超过列表长度，插入的元素直接添加在列表的末尾

判断元素是否在列表中

1、使用in来判定某个元素是否在列表中。

a=[1,2,3,4]

print(1 in a)

print(10 in a)

结果如下：

与in相对应的还有一个not in

print(1 not in a)

判断1是否不在a中

2、使用index方法，来判定，当前元素在列表中的位置，得到一个下标

a=[1,2,3,4]

print(a.index(2))

print(a.index(10)) //若元素不在列表中，抛出异常

删除元素

1、使用pop方法删除最末尾元素

alist=[1,2,3,4]

alist.pop()

2、pop也可以按照下标来删除元素

alist=[1,2,3,4]

alist.pop(2)

print(alist)

结果如下：

3、使用remove方法删除对应值的元素

alist=[1,2,3,4]

alist.remove(2)

连接列表

1、使用+能够把两个列表拼接在一起

此处的+结果会生成一个新的新列表，而不会影响旧列表的内容

alist=[1,2,3,4]

blist=[5,6,7]

print(alist+blist)

结果如下：

2、使用extend拼接（效率比较高）

这个拼接是把后一个列表的内容拼接到前一个列表里

extend方法没有返回值

alist=[1,2,3,4]

blist=[5,6,7]

c=alist.extend(blist)

print(alist)

print(blist)

print(c)

结果如下：

python中"None"这是一个特殊的变量的值，表示啥都没有

3、使用+=进行拼接

alist=[1,2,3,4]

blist=[5,6,7]

alist+=blist

print(alist)

结果如下：

元组

创建元组

创建元组有两种方法：

//1.方法1

a=()

//2.方法2

b=tuple()

指定初始值

创建元组时可以指定初始值，元组中的元素也可以是任意类型

a=(1,2,3,4,5)

下标访问

也可以通过下标访问元组的元素，越界也是抛异常

a=(1,2,3,4,5)
print(a[1])

切片操作

a=(1,2,3,4,5)
print(a[1:3])

循环遍历

a=(1,2,3,4,5)
for elem in a:
print(elem)

in判断元素是否存在，index获取下标

a=(1,2,3,4,5)

print(3 in a)

print(a.index(3))

使用+拼接两个元组

a=(1,2,3)
b=(4,5,6)
print(a+b)

元组只支持读操作，不支持改操作，因此不支持pop，extend，append方法

当进行多元赋值的时候，其实本质上就是按照元组的方式进行工作的

def getPoint():
    x=1
    y=2
    return x,y

print(type(getPoint()))

结果如下：