PYTHON 基础语法PYTHON基本数据类型Python.运算符数字（Number）字符串列表元组字典集合循环语句迭代生成器函数

83 阅读 0 评论 55 点赞

我是靠谱客的博主聪慧铅笔，最近开发中收集的这篇文章主要介绍PYTHON 基础语法PYTHON基本数据类型Python.运算符数字（Number）字符串列表元组字典集合循环语句迭代生成器函数，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

基础语法

多行语句

python通常一行写完一条语句，如果太长的话，一般使用 " " 来换行。

例如：

sum = data1+
data2+
data3

但是在有括号时则不需要使用 " " 。

例如：

sum = ['data1',
'data2',
'data3']

数字类型

python有四种数字类型：整数型，浮点数，布尔数和复数。

int（整数形）普通定义的整数

bool（布尔数）true 和 false ，分别表示1和0

float（浮点数）带有小数，例如3.14，5E-31

complex（复数）如：1+2j，1.1+3.14j

字符串

str='DJH,SDhana'
print(str)#输出字符串
print(str[0:-3])#输出第一个到导数第四个字符
print(str[4:])#输出从第5到最后的字符
print(str*3)#输出字符串3次
print(str[0::2])#对该字符串每隔一个输出一个字符
print(str+',HWTMY')#连接字符串
print(str[6])#输出第7个字符
print('DJHnnh')#n表示换行
print(r'DJHnnh')#在字符串前加上r则不会自动换行

结果如下：

DJH,SDhana
DJH,SDh
SDhana
DJH,SDhanaDJH,SDhanaDJH,SDhana
DHShn
DJH,SDhana,HWTMY
h
DJH
nh
DJHnnh

用户输入

在input输入后会输出

例如：

x=input('请输入内容：n')
print(x)

输出（print）

print默认输出换行，要想不换行，在最后加入end = " "

例如：

print('DJH,SDHHNA',end=" ")

import 和 from...import

将模块A整个导入：import A

将模块A中的函数B导入：from A import B

将模块A中的函数B和C导入：from A import B，C

将模块A中的全部函数导入：from A import*

PYTHON基本数据类型

python允许同时为多个变量赋值

例：

a = b = c = 1

也可以为多个对象制定多个变量

例：

a, b, c = 1, 2, "123"

python中，有六个标准的数据类型：

Numbe(数字)

String(字符串)

Tuple(元组)

以上三种不可变，以下三种可变

List(列表)

Set(集合)

Dictionary(字典)

Number（数字）

数字类型包括 int ， float， bool， complex

int 既是整型，也是长整型

type() 函数可以查询变量类型,也可以用isinstance（）函数来判断是不是某类型数据（这里都需要用print函数来显示结果。）

String见第一篇笔记

List（列表）

List是写在 [ ] 中间，用 “ , ” 隔开的元素列表。，索引时从0为开始值，-1为从末尾开始的位置，加号 + 是列表连接运算符，星号 * 是重复操作。

列表可以进行数据的修改:

list1 = [1, 2.3, 'djh']
print(list1)
a = input("path:")
b = input("value:")
list1[int(a)] = b
print(list1)

此处在指定修改位置时，要对位置编号进行类型强制转换为 int

Tuple（元组）

元组和列表类似，但是里面元素不可修改

tuple1 = ()#空元组
tuple2 = (1,)#只有一个元素的元组要有“ , ”
tuple3 = (1,2,'3')

Set（集合）

这里的集合不是数组，队列之类，而是数学上的集合

创建集合：

a = {'wasd', 'o', 'o', 'l'}
#或者
b = set("wool")

空集合只能用 set() 。

集合运算：

a = {'sc','kd','kt','ai','dg'}
b = {'sc','kd','fyq','jbx','sg'}
if 'sc' in a:
print('YES')
else:
print('NO')
print(a-b)#a-b差集
print(a|b)#ab的并集
print(a&b)#ab的交集
print(a^b)#ab中不同时存在的元素

Dictionary（字典）

字典是 python 中内置的数据类型，列表是有序对象的集合，字典是无序对象的集合。

字典中的元素通过键来存取，不是通过偏移存取。

字典是一种映射类型，用 { } 标识，是一个无序的 键（key）:值（value）的集合

键（key）必须使用不可变类型。在同一个字典中，键必须是唯一的。

创建空字典使用 a = { }

实例：

dict = {}
dict['one'] = "1-cai niao jiao cheng"
dict[2] = "2- cai niao gong ju "
tinydict = {'name':'runoob','code':'1','site':'www.baidu.com'}
print(dict['one'])
print(dict[2])
print(tinydict)
print(tinydict.keys())
print(tinydict.values())

使用dict（）函数直接从键值对序列中构建字典例：

a = dict([('Runoob', 1), ('google', 2), ('taobao', 3)])
b = dict(Runoob=1, google=2, taobao=3)
c = {'Runoob': 1, 'google': 2, 'taobao': 3}
print(a)
print(b)
print(c)

Python 数据类型转换

x = 123
str(x)#转换为字符串
repr(x)#转换为表达式字符串
eval(x)#
tuple(x)#元组，列表，集合，字典
list(x)
set(x)
dict(x)
chr(x)#整数变字符
ord(x)#字符转换为整数值
hex(x)#整数变为16进制字符串
oct(x)#整数变为8进制字符串

Python.运算符

赋值运算符

%= ：取模赋值运算符

c%a 等效于c = c % a

**= ：幂赋值运算符

c**a 等效于c = c ** a

//= ：取整除赋值运算符

c// = a 等效于 c = c // a

:= ：海象运算符，可在表达式内部为变量赋值

if(n:=len(a))>10
print(f"Lists is too long ({n} elements,expected <= 10)")

位运算符

& 与运算

| 或运算

^ 异或运算：两对应的二进位相异时，结果为1

~ 按位取反运算：对数据的每个二进制位取反,即把1变为0,把0变为1。

<< 左移动运算：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

>> 右移动运算：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

例：

a = 60
# 60 = 0011 1100
b = 13
# 13 = 0000 1101
c = 0
c = a & b
# 12 = 0000 1100
print("a :", c)
c = a | b
# 61 = 0011 1101
print("b :", c)
c = a ^ b
# 49 = 0011 0001
print("c :", c)
c = ~a
# -61 = 1100 0011
print("d :", c)
c = a << 2
# 240 = 1111 0000
print("e :", c)
c = a >> 2
# 15 = 0000 1111
print("f :", c)

逻辑运算符

and : a and b 成立返回 b，否则返回a

or : a or b a 成立返回a 否则返回b

not :not a a成立返回false 否则返回true

成员运算符

in 若在序列中找到值返回true 否则返回false

not in 若在序列中没找到返回true 否则返回false

a = 1
b = 666
list = [1,2,3,10]
if a in list:
print("true")
else:
print("false")
if b not in list:
print("true")
else:
print("false")

python 身份运算符

用于比较两个对象的存储单元

is ：判断两个标识符是否引自同一个对象

is not ：判断两个标识符是否引用自不同对象

a = 20
b = 20
if a is b:
print("same")
else:
print("differ")
if id(a) == id(b):
print("same")
else:
print("differ")
a=30
if a is b:
print("same")
else:
print("differ")
if id(a) == id(b):
print("same")
else:
print("differ")

is与==的区别：

==：判断两个变量的值是否相等

is：判断两个变量引用对象是否相同

运算符优先级

从高到低：

指数(**)>按位翻转(~+-)>乘除求余数取整(* / % //)>加减(+-)>右移左移位运算(>> <<)>位‘and’(&)>位运算符(^ |)>比较运算符(<= < > >=)>等于运算符(= !=)>赋值运算符(= %= /= //=-= += *= **=)>身份运算符(is not is)>成员运算符(in not in)>逻辑运算符(not and or)

and 拥有更高的优先级：

a = True
b = False
c = False
if a or b and c:
print("yes")
else:
print("no")

yes

数字（Number）

数字类型转换：

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

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

/：总是返回一个浮点数使用 // 可以只保留整数部分（与分子分母数据类型有关）

不同类型数据运算时，会转换为浮点型

在交互模式中，最后被输出的表达式结果被赋值给变量 _

数学函数

abs（x）：求绝对值

ceil（x）：返回数字的上入整数（ceil（4.1）=5）

~~cmp（x，y）：x<y返回-1；x==y返回0；x>y返回1.（python2采用）~~

exp(x) ：返回e的x次幂

fabs（x）：返回绝对值（浮点数）在math中

floor(x)：返回下舍整数（floor（4.9）=4）

log(x) : log（100,10）=2

log10(x) :返回以10为基数的x的对数

max(x1,x2,x3...):返回指定参数最大值

min(x1,x2,x3...):返回指定参数最小值

modf（x）：返回x的整数部分和小数部分，整数部分用浮点数表示

pow（x,y）x**y运算后的值

round（x，[n]）：返回浮点数x的四舍五入值，n代表舍入到小数点后的位数

sqrt（x）：返回数字x的平方根

随机数函数

choice(seq):从序列元素中随机挑选一个元素

randrange（[start,] stop [,step.]）：从指定范围中，按照基数递增的集合中获取一个随机数

random ：随机生成一个数，在[0,1)之间

seed（【x】）：

shuffle（lst）：将序列所有元素随机排序

uniform（x，y）：随机生成下一个实数，在【x，y】范围内

pi：圆周率

e：自然常数

字符串

使用引号（ ' 或者 " ）来创建字符串

var1 = 'Hello World'

访问字符串中的值

python 中不支持单字符类型，一个字符也作为一个字符串来使用。

访问子字符串用 [ ] 来截取。（变量[头下标：尾下标] ）例：

str = 'RUNOOB'
print(str[0])
print(str[:])
print(str[3:])
print(str[:3])
print(str[1:5])

字符串更新

str = 'Run oob'
print("字符串更新为："+ str[:4]+'out')

转义字符

：续行符

\ ：反斜杠符号

' ：单引号

" ：双引号

a ：响铃

b ：退格

00 ：空

v :纵向制表

t :横向制表

r :将 r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 r 后面的内容完全替换完成。

f: 换页

yyy:八进制数

xyy:

other :

字符串运算

a = "Hello" b =" Python"

+ ：字符串连接

* : 重复输出字符串

[ ] ：通过索引获取字符串中的字符

[ : ] : 截取字符串中的一部分，左闭右开原则 [0:2]不包含第三个字符。

in :成员运算符，若字符串中包含则为true

not in：成员运算符，若字符串中不包含则为true

r/R : 原始字符串，所有字符都是按照字符串本身使用

列表

列表正向从0开始，逆向从-1开始。

+ 用于列表组合，* 用于重复列表。

删除列表元素

使用 del 语句实现删除元素

List = ['Google', 'Runoob', 'Taobao', 'Baidu']
print(List)
del List[int(input())]#输入想要删除的元素的位置
print(List)

['Google', 'Runoob', 'Taobao', 'Baidu']
2
['Google', 'Runoob', 'Baidu']

嵌套列表

List1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
List2 = ['Amzon', 'Jd', 'Huawei', 'Iphone']
print([List1, List2])

[['Google', 'Runoob', 'Taobao', 'Baidu'], ['Amzon', 'Jd', 'Huawei', 'Iphone']]

列表的函数和方法

函数：

len(list),列表的元素个数

max(list),列表元素最大值，整型，浮点型

min(list)

list(seq)，元组转换为列表

方法：

List2 = ['Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone']
List = [1, 2, 3]
List2.append('wtf') #末尾添加元素 wtf
print(List2)
c = List2.count('Amzon') #统计 Amzon出现的次数
print(c)
List.extend(List2) #在List末尾追加List2
print(List)
print(List.index(2))#找出List中第一个 2 的位置
List2.insert(0, 'shit')#在List2 的第一个元素位置插入 shit
print(List2)
List2.pop(0)#移除List2 的第一个元素
print(List2)
List.remove(3)#移除List中第一个 3
print(List)
List2.reverse() #倒序List2
print(List2)
List.clear()#清空List
print(List)
a = List.copy()#复制List
print(a)

['Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone', 'wtf']
2
[1, 2, 3, 'Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone', 'wtf']
1
['shit', 'Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone', 'wtf']
['Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone', 'wtf']
[1, 2, 'Amzon', 'Amzon', 'Jd', 'Huawei', 'Iphone', 'wtf']
['wtf', 'Iphone', 'Huawei', 'Jd', 'Amzon', 'Amzon']
[]
[]

元组

元组使用（）列表使用 [ ] ，元组的元素在括号中添加，使用逗号隔开

tuple = ()#空元组

元组的操作包括访问元组，修改元组，删除元组，以及一些运算符

#!/usr/bin/python3
tup1 = (50,60,70)
tup2 = ("Djh", 'Sd', 'Bab')
tup3 = tup1 + tup2#元组组合
print(tup1[::-1])#元组访问
print(tup1[0])
print(tup3)
del tup3
#元组删除
#此时若输出tup3，会报错
a = len(tup1)
#元组长度
b = tup2*3
#重复输出
c = 20 in tup1
#元素是否存在
print(a,b,c)
for x in tup1:
#迭代
print(x)

结果：

D:PYTHONpython.exe "C:/Users/Brother DA/Desktop/PCB实验报告/demo.py"
(70, 60, 50)
50
(50, 60, 70, 'Djh', 'Sd', 'Bab')
3 ('Djh', 'Sd', 'Bab', 'Djh', 'Sd', 'Bab', 'Djh', 'Sd', 'Bab') False
50
60
70
进程已结束,退出代码0

内置函数：

len max min tuple

元组不可变值得是元组指向的内存中的内容不可变

字典

字典的每个键值对（key=>value）用冒号 : 分隔,每个对之间用逗号（ , ）分隔。

整个字典包括在花括号中 { }，格式如下：键：值

d = {'Name': 'SongDa', 'Age': 19, 'Job': 'Student'}

键必须是唯一的，但是值不必须是唯一的。

访问、修改、删除字典：

d = {'Name': 'SongDa', 'Age': 19, 'Job': 'Student'}
print(d['Name'])
#访问字典里的值
d['Age'] = 20
#修改字典里的某个值
d['Son'] = 'Zmq'
#添加信息
del d['Job']
#删除某个键
print(d)
d.clear()
#清空字典
del d
#删除字典
print(d)

结果：

D:PYTHONpython.exe "C:/Users/Brother DA/Desktop/PCB实验报告/demo.py"
SongDa
{'Name': 'SongDa', 'Age': 20, 'Son': 'Zmq'}
Traceback (most recent call last):
File "C:/Users/Brother DA/Desktop/PCB实验报告/demo.py", line 12, in <module>
print(d)
NameError: name 'd' is not defined
进程已结束,退出代码1

键的特性：

（1）不可重复性：一个键只允许出现一次

（2）不可变性：键不可变，因此可用数字、字符串、元组充当，列表就不可以

内置函数：

len str type

集合

集合是无序的不重复元素序列

可以使用大括号 { } 或者set（）来创建，空集合用 set（）来创建，空字典是 { }

添加、移除、计数、清空、判断存在

s = {123, 'Djh'}
print(s)
s.add('SD')#添加元素
print(s)
s.remove(123)#移除元素
s.discard(123)
print(s)
s.pop()#随机删除
print(s)
print(len(s))#计算长度
s.clear()#清空集合
print(s)

运算

x = {123, 'Djh'}
y = {456, 'Sd'}
a = x.difference(y)#x与y的差集
b = x.intersection(y)#集合的交集
c = x.isdisjoint(y)#判断两集合是否有相同元素
d = x.issubset(y)#判断是否为子集
e = x.symmetric_difference(y)#两集合中不重复的元素集合
f = x.union(y)#并集
g = x.update(y)#给集合添加元素
print(a)

循环语句

while 循环

形式：

while 判断条件(condition)：

执行语句(sentnces)

n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum+counter
counter +=1
print("1到%d之和为：%d" % (n, sum) )

无限循环

可以通过设置条件表达式的值永不为false来实现无限循环

例：

var =1

while var == 1：

while ... else

while(expre):

(sentences)

else: