Python7.16

环境配置

Pyhon解释器安装

IDE安装（Python）

Typora安装

正课内容

python创始人：吉多·范罗苏姆

云计算，web开发，科学运算，人工智能

编译型和解释型，静态语言和动态语言，强类型定义语言和弱类型定义语言。

python动态解释性强类型定义语言。

1.python的历史概况

（1）python的出身和应用

（2）python是什么样的语言

·动态

·静态

·编译

·解释

·强类型

·弱类型

（3）优缺点

（4）python的种类

2.python基础

##2.1第一条编程语句

print("hello world")

print("hello python")
print("to be, or not to be,it's a question.")
print("to be,or not to be,it's up to you")
print("Make it")

##2.2print()函数

打印信息

2.3注释

单行注释

#这里是注释

多行注释

​ 三单引号

​ 三双引号

'''
多行注释1
'''
"""
多行注释2
"""

demo:

print("hello python")  # 第一条python程序
print("to be, or not to be,it's a question.")
print("to be,or not to be,it's up to you")
print("Make it")
'''
python
'''

2.3input()函数

作用：从外部获取值

用法：Help on built-in function input in module builtins:

input(prompt=None, /)
Read a string from standard input. The trailing newline is stripped.

The prompt string, if given, is printed to standard output without a
trailing newline before reading input.

If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
On *nix systems, readline is used if available.

2.4运行Python程序的三种方式

（1）解释器环境运行

（2）脚本运行

（3）IDE

pycharm

sublime

Vs code

Atom

2.5Python中常见的数据类型

数据的概念

Python中的数据类型（常见）

• ​ 数字number

  整型（int）

​ 浮点型（float）

​ 布尔型（bool）

​ 复数（complex）

• 字符串（string)

• 列表(list)

• 元祖(tuple)

• 字典(dict)

• 集合(set)

2.6变量和常量

变量

• 概念

  • 程序可操作的存储区

  • 程序运行时存储区中能改变的数据

    每个变量都有自己的特定的数据类型

• 作用

• 将数据储存到内存

• 变量的定义

  • 命名

  规则：

  • 必须是字母数字组合
  • 不能以数字开头
  • 不可以是Python中的关键字

注意：

• 见名知意

• 区分大小写

• 在Python中，单下划线和双下划线开头的变量有特殊的用途，一般不推荐使用单下划线和双下划线开头的变量名称

• 变量定义

  • val_name = 初始值

拓展：

关键字查看

/usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

类型测试

内存地址id()

type(val_name)

内存地址

id(val_name)

常量

不变的量

pi，3.1415926

通常用大写，如

PI = 3.1415926

互换2个元素的值

x = 123
y = 456

x, y = y, x
print(x)
print(y)

2.7数字

• 整型(int)

  • 32bit,取值范围$-2^{31}-2^{31}-1$
  • 64bit,取值范围$-2^{63}-2^{63}-1$

• 浮点型

• 带有小数点的数字

• 布尔型（bool）

  • true
  • false

• 复数（complex）

  • 实部
  • 虚部
  • 共轭复数

  cpx = complex(3, 4)
  print(cpx)
  cpx.real#实部
  cpx.imag#虚部
  

常见的数学函数

函数名	描述
Abs(x)	绝对值
pow(x,y)	$x^y$
round(x,[n])	返回四舍五入的值，如果给出n，表明四舍五入后的小数点的位数
math.exp(x)	返回e的x次幂
math.fabs(x)	返回绝对值，类型为浮点数
math.ceil(x)	返回数字的上入整数
math.floor(x)	返回数字的下舍整数
math.log(x,[y])	单参数默认以e为底，双参数，以[y]为底
matn.modf(x)	返回浮点数的小数部分和整数部分
math.sqrt(x)	平方根
$max(x_1,x_2,...)$	返回最大值
$min(x_1,x_2,...)$	返回最小值

2.8表达式运算符

• 表达式

  • 由变量，常量和运算符组成的式子，成为表达式

• 运算符

  • 算术运算符
  • 比较运算符
  • 逻辑运算符
  • 赋值运算符
  • 成员运算符
  • 身份运算符
  • 位运算符

Python算术运算符

运算符	描述	实例
+	相加/拼接	a-b
-	相减/求差集	a-b
*	相乘/重复	a*b
/	相除	a/b
**	幂运算	x**y
%	取模（余数）	a%b
//	取整除商	a//b

拓展

divmod(x,y)

x除y，第一个值返回商，第二个值返回余数

Python比较运行符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Python赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

Python位运算符

按位运算符是把数字看作二进制来进行计算的。常见的位运算符如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

a = 15
b = 31
# 二进制对应
# a->00001111
# b->00011111
# a&b00001111
#a|b00011111
#a^b 0001 0000
#a>>2 0000 0011
#a<<2 0011 1100

Python成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

#!/usr/bin/python3
 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

#!/usr/bin/python3

 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

#!/usr/bin/python3
 
a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

2.9数据类型的强制转换

强转类型	描述
int(x,[base])	将x强制转化为整型。如果x是字符串，需要制定base基数，base是什么进制
float(x)	将x强制转换成浮点型
str(x)	强转为字符串
repr(x)	将对象转换为表达式字符串
list(x)	将对象转换为列表
tuple(x)	将对象转换为元祖
dict(x)	将对象转换为字典
set(x)	set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
chr(x)	将整数转化为字符
ord(x)	将字符转化为数值
bin(x)	转换为二进制
oct(x)	转换为八进制
hex(x)	转换为十六进制

#int
>>>a=12.3
>>>int(a)
12
>>>sr="123"
>>>int(sr)
123
>>>int(sr,8)
>>>8**2+2*8+3
83
>>>int(sr,16)
291

2.10随机函数

导入模块

import random

(1)random.random()

• 用来生成一个0-1的随机浮点数[0，1）

  import random
  a=random.random()
  print(a)
  /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
  0.5359252986822483
  
  Process finished with exit code 0
  
  

(2)random.uniform(a,b)

用来生成指定范围内的浮点数，[a,b]

import random
a=random.uniform(1,10)
print(a)
/usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
8.205157437180954

Process finished with exit code 0

(3)random.randint(a,b)

• 用来生成指定范围内的整数，[a,b]

• import random
  a=random.randint(1,10)
  print(a)
  /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
  5
  
  Process finished with exit code 0
  
  

(4)random.randrange([start],stop,[step])

• 从指定范围内，安指定基数递增或递减的集合中，随机获取一个整数

• import random
  
  for i in range(100):
      a = random.randrange(1, 16, 3)
      print(a, end=" ")
      
      /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
  7 4 10 10 7 1 7 7 13 1 13 4 7 7 4 10 7 10 4 10 10 10 13 4 10 10 4 7 4 7 1 1 7 10 1 4 1 13 1 1 1 1 7 13 4 10 10 4 1 13 10 10 7 13 10 4 7 10 13 7 10 1 10 10 7 10 10 13 1 4 7 4 10 4 4 1 1 7 7 7 7 13 4 7 1 10 13 7 10 13 4 7 13 13 4 13 1 1 7 13 
  Process finished with exit code 0
  
  

(5)random.choice(sequeue)

• 从序列中随机获取一个元素（sequeue)可以为列表，字符串或者元祖

import random

for i in range(100):
    a = random.choice(range(1, 16, 2))
    print(a, end=" ")
    
    /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
1 5 13 11 9 5 13 11 1 3 13 9 15 7 11 5 1 5 1 9 3 11 5 5 9 13 7 5 15 5 3 9 15 1 5 5 3 7 1 11 1 11 1 3 3 15 7 15 9 15 3 3 7 5 3 9 5 9 15 13 1 7 1 7 3 11 11 11 7 13 15 11 7 11 15 11 15 15 3 1 11 1 13 15 15 11 7 15 1 3 15 13 1 5 3 3 15 13 15 13 
Process finished with exit code 0

(6)random.shuffle(x,[random])

• 用来将一个列表顺序打乱

• import random
  li =["1","2","3"]
  for i in range(3):
      random.shuffle(li)
      print(li)
      
      /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
  ['3', '1', '2']
  ['3', '1', '2']
  ['2', '1', '3']
  
  Process finished with exit code 0
  

(7)random.sample(sequeue,k)

• 用来指定序列中随机获取指定长度的片段并随机排列。但，不会修改原来序列。

• import random
  
  li = ["1", "2", "3"]
  for i in range(3):
      a = random.sample(li, 2)
      print(a)
      
      /usr/local/bin/python3.6 /Users/shaojun/PycharmProjects/7.16/1.py
  ['2', '1']
  ['3', '1']
  ['2', '3']
  
  Process finished with exit code 0