02_Python基础

2.1 第一条编程语句

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!")
print("以梦为马，不负韶华!")

2.2 print()函数

作用：在控制台打印信息；

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

2.3 注释

• 单行注释
  • 一个“#”

# 这是单行注释

• 多行注释
  • 三单引号
  • 三双引号

'''
多行注释1
'''

"""
多行注释2
"""

demo:

print("Hello, Python!") # 第一条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!")
print("以梦为马，不负韶华!")
'''
让我们开始Python之旅，
畅行在Python之途！
'''

2.3 input()函数

作用：从外部获取值

用法：括号中可以提供提示信息

返回值为字符串类型

>>> a = input()
城市学院
>>> a
'城市学院'
>>> a = input("Please Enter School Info：")
Please Enter School Info：City College
>>> a
'City College'
>>>

20190716上午

---

2.4 运行Python程序的三种方式

(1) 解释器环境运行

C:\Users\King>python
Python 3.6.5 |Anaconda, Inc.| (default, Mar 29 2018, 13:32:41) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello,World")
Hello,World
>>>	

(2) 脚本运行

C:\Users\King>python hello.py # 进入脚本对应的路径

或者

C:\Users\King>python d:hello.py # 进入脚本对应的路径

(3) IDE

• pycharm
• sublime
• VS Code
• Atom

集成开发环境通常整合了文本编辑器、集成的调试器等工具，支持各种源代码控制工具。

# -*- coding: utf-8 -*-
# 或者
#coding:utf-8

2.5 Python中常见的数据类型

数据的概念

计算机顾明思议就是可以做数学运算的机器,因此计算机理所当然的可以处理各种数据,但是计算机能处理的远远不止数值,还有文本,图形,音频,视频网页等各种数据, 不同数据,需要定义不同的数据类型

Python中的数据类型（常见）

• 数字（number）
  • 整型（int）
  • 浮点型（float）
  • 布尔型（bool）
  • 复数（complex）
• 字符串（string）
• 列表（list）
• 元组（tuple）
• 字典（dict）
• 集合（set）

2.6 变量和常量

变量

• 概念：

  • 程序可操作的存储区的名称；
  • 程序运行时存储区中能够改变的数据；

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

• 作用：

  • 将数据存储到内存

• 变量的定义

  • 命名

  规则：

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

注意：

• 见名知意
• 区分大小写
• 在Python中，单下划线和双下划綫开头的变量有特殊的通途，一般不推荐使用单下划线和双下划綫开头的变量名称

• 变量定义

  • val_name = 初始值
    
    

拓展：

关键字的查看

>>> import keyword
>>> keyword.kwlist
['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']

一下变量名称哪些是正确的，哪些是错误的？

666，错

City666,对

_56city,对

类型测试 type()

type(val_name)

内存地址 id()

id(val_name)

常量

常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量。在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量。

通常用大写，如

PI = 3.1415926

举例：

>>> a = 1
>>> b = 6.6
>>> c = "xyz"
>>> tp = 1, 2, 3
>>> x, y, z = tp
>>> x
1
>>> y
2
>>> z
3
>>> type(tp)
<class 'tuple'>
>>>
>>>
>>> a, b, c = 111, 222, 33
>>> a
111
>>> b
222
>>> c
33
>>> a = 111
>>> b = 222
>>> c = 333
>>> x = "abc"
>>> y = "def"
>>>
>>> z = x, y
>>> type(z)
<class 'tuple'>
>>>

互换两元素的值：

>>> a = 123
>>> b = 456
>>> tmp = a
>>> a = b
>>> b = tmp
>>>
>>> a
456
>>> b
123
>>>
>>> x = 123
>>> y = 456
>>> x, y = y, x
>>> x
456
>>> y
123

2.7 数字

种类

• 整型（int）

  • 32bit，取值范围 \(-2^{31} - 2^{31}-1\)
  • 64bit，取值范围\(-2^{63} - 2^{63}-1\)

  以前Python区分短整型和长整型，目前，无这些区分。

• 浮点型（float）

  • 带有小数点的数字

• 布尔型（bool）

  • True
  • False

• 复数（complex）

  • 实部 （cpx.real）
  • 虚部 （cpx.imag）
  • 共轭复数 （cpx.conjugate()）

常见的数学函数

函数名	描述
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]为底
math.modf(x)	返回浮点数的小数部分和整数部分
math.sqrt(x)	平方根
\(max(x_1, x_2, ...)\)	返回最大值
\(min(x_1, x_2, ...)\)	返回最小值

2.8 表达式与运算符

• 表达式

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

• 运算符

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

Python算术运算符

运算符	描述	实例
+	加 : 两个对象相加	a + b
-	减 :得到负数或是一个数减去另一个数	a - b
*	乘 : 两个数相乘或是返回一个被重复若干次的字符串	a * b
/	除 : x 除以 y	b / a
**	幂 : 返回x的y次幂	a**b
%	取模 : 返回除法的余数	b % a
//	取整除 : 向下取接近除数的整数	a//b

拓展：
divmod(x, y)

>>> divmod(23, 4)
(5, 3)

a = 6
b = 12
c = 0
 
c = a + b
print ("1: c 的值为：", c)
 
c = a - b
print ("2: c 的值为：", c)
 
c = a * b
print ("3: c 的值为：", c)
 
c = a / b
print ("4: c 的值为：", c)
 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(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赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	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位运算符

运算符	描述
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

下表中变量 a 为 31，b 为 15二进制格式如下：

a =    0001 1111
b =    0000 1111
----------------
a&b =  0000 1111
a|b =  0001 1111
a^b =  0001 0000
~a =   1110 0000
a<<2 = 0111 1100
a>>2 = 0000 0111

>>> a = 31
>>> b = 15
>>> a & b
15
>>> a | b
31
>>> a ^ b
16
>>> ~a
-32
>>> a << 2
124
>>> a >> 2
7

Python逻辑运算符

Python语言支持逻辑运算符，

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

同样仍以变量 a 为 31，b 为 15为例：

>>> a and b
15
>>> a or b
31
>>> not a
False

针对逻辑运算的进一步研究：

　　1,在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。

判断逻辑语句的正与负：

3>4 or 4<3 and 1==1 #
1 < 2 and 3 < 4 or 1>2 #
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6#

3>4 or 4<3 and 1==1 #F
1 < 2 and 3 < 4 or 1>2 #T
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1 #T
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8 #F
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 > 8 #T
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #F
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6#F

python成员运算符

测试是否包含某个成员，一般测试字符串，列表，元组

运算符	描述
in	如果存在于指定序列中，返回True；否则，False
not in	如果不存在于指定序列中，返回True；否则，False

Demo：

>>> sr = "abc"
>>> "a" in sr
True
>>> "a" not in sr
False

>>> li = list(sr)
>>> li
['a', 'b', 'c']
>>> "a" in li
True
>>>

python身份运算符

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

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

运算符	描述
is	判断两个标识符是不是引用自同一个对象
not is	判断两个标识符是不是引用自同一个对象

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

2.9 数据类型的强制转换

强转类型	描述
int(x, [base])	将x强制转化为整型。如果x是字符串，需要制定base基数
float(x)	将x转换为浮点型
str(x)	强转为字符串
repr(x)	将对象转换为表达式字符串
list(x)	将对象转换为列表
tuple(x)	将对象转换为元组
dict(x)	将对象转换为字典
set(x)	将对象转换为集合
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)
83
>>> 8**2 + 2 * 8 + 3
83
>>> int(sr, 16)
291

拓展

小数据池

- 数字小数据池的范围 -5 ~ 256

- 字符串中如果有特殊字符他们的内存地址就不一样

- 字符串中单个*20以内他们的内存地址一样,单个*21以上内存地址不一致

>>> a1 = -6
>>> a2 = -6
>>> a1 == a2
True
>>> a1 is a2
False
>>>
>>> b1 = -5
>>> b2 = -5
>>> b1 == b2
True
>>> b1 is b2
True
>>>
>>>
>>> s1 = 'demo#'
>>> s2 = 'demo#'
>>> s1 == s2
True
>>> s1 is s2
False
>>>

>>> for i in [19, 20, 21]:
...     a = 'a'*i
...     b = 'a'*i
...     print(a == b)
...     print(a is b)
...
True
False
True
False
True
False
>>> s1 = 'aaaaaaaaaaaaaaaaaaaa'
>>> s2 = 'aaaaaaaaaaaaaaaaaaaa'
>>> s1 is s2
True
>>> s2 = 'aaaaaaaaaaaaaaaaaaaaa'
>>> s1 = 'aaaaaaaaaaaaaaaaaaaaa'
>>> s1 is s2
True
>>>
# 第三条待考证

2.10 随机函数

导入这个模块

import random

random模块的常见功能：

(1) random.random()

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

import random
# print(dir(random))
for i in range(100):
	a = random.random()
	print(a, end=" ")

(2) random.uniform(a, b)

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

import random
# print(dir(random))
for i in range(100):
	a = random.uniform(6, 8)
	print(a, end=" ")

(3) random.randint(a, b)

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

import random
# print(dir(random))
for i in range(100):
	a = random.randint(6, 10)
	print(a, end=" ")

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

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

random.randrange(1, 16, 2)

1， 3， 5， 7， 9， 11， 13， 15

import random
for i in range(100):
	a = random.randrange(1, 16, 2)
	print(a, end=" ")

(5) random.choice(sequence)

• 从序列中随机获取一个元素，sequence可以为列表，字符串或者元组

import random
for i in range(100):
	# a = random.randrange(1, 16, 2)
	b = random.choice(range(1, 16, 2))
	print(b, end=" ")

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

• 用来将一个列表的元素打乱。即将列表的元素随机排列。

import random
li = ["C Language", "C++", "Java", "VB", "C#", "Python"]
# sr = "C Language"
for i in range(6):
	# a = random.randrange(1, 16, 2)
	random.shuffle(li)
	print(li)

(7) random.sample(sequence, k)

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

import random
li = ["C Language", "C++", "Java", "VB", "C#", "Python"]
for i in range(6):
	print(random.sample(li, 4))