PYTHON

 基础语法

多行语句

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('DJH\nnh')#\n表示换行
print(r'DJH\nnh')#在字符串前加上r则不会自动换行

结果如下：

DJH,SDhana
DJH,SDh
SDhana
DJH,SDhanaDJH,SDhanaDJH,SDhana
DHShn
DJH,SDhana,HWTMY
h
DJH
nh
DJH\nnh

用户输入

在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 ：退格

\000 ：空

\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:\PYTHON\python.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:\PYTHON\python.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:

        (sentences)

for

for  (var) in (sequence):

        statements

else:

        statements

range()函数 

for i in range(5, 20, 3):
    print(i)
5
8
11
14
17

continue

x = 6
while x > 1:
    x -= 1
    if x ==3:
        continue
    print(x)
5
4
2
1

pass

for letter in 'Google':
    if letter == 'o':
        pass
        print("执行pass")
    print('当前字母：', letter)

当前字母： G
执行pass
当前字母： o
执行pass
当前字母： o
当前字母： g
当前字母： l
当前字母： e

进程已结束,退出代码0

迭代生成器

迭代器

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)

StopIteration 异常用于标识迭代的完成，防止出现无限循环

生成器

import sys
def fibonacci(n):
    a, b, counter = 0, 1, 0
    while True:
        if counter > n:
            return
        yield a
        a, b = b, a+b
        counter += 1
f = fibonacci(10)

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

函数

函数定义使用def开头，后接函数标识符名称和圆括号（）。

任何传入参数和自变量必须放在圆括号中，括号之间可以用于定义参数。

return[ 表达式 ]结束函数，不带表达式的return相当于none。

def podd(n):
    if n%2 ==0:
        print(n, "为偶数")
    else:
        print(n, "为奇数")

n = int(input())
podd(n)