Python 入门（数据结构类型，基础运算符，分支，循环）

Python入门

1.第一条python程序

print('Hello World')

2.基础数据类型

2.1在 Python 的数字有 4 种数据类型，分别为：

int（有符号整型）
float（浮点型）
complex（复数）

print(type(123))
print(type(123.0))
print(type('123'))
print(type("123"))

上面示例的运行结果如下：

<class 'int'>
<class 'float'>
<class 'str'>
<class 'str'>

123 是整形（int）
123.0 是浮点型（float）
‘123’ 和 “123” 的类型是一致的，都是字符串 str（注意，有单双引号，如果无引号则不会认为是字符串类型）

2.2进制

十进制：正常写就 ok ，所有的数字都默认是十进制的。
二进制：在最前面添加 0b 的前缀，并且组成部分必须只能由 0 或者 1 组成（废话，有其他数字还叫二进制么），如： 0b10101010101
八进制：在最前面添加 0o 的前缀，并且组成部分必须只能有 0~7 的数字组成，如：0o12345670
十六进制：在最前面添加 0x 的前缀，并且组成部分由 0~9 和 A~F 组成，如：0xdb273dc（注意：字母大小写不做区分，也可以写成 0xDB273DC ）

2.3布尔值

print(123 == 123.0)
print(123 == '123')

输出结果

True
False

结论：==只能用来做数值的比较，并不会比较当前的数据类型，所以 123 和 123.0 是相等的。而 ‘123’ 不等于 123 则是因为 ‘123’ 是字符串，不能数值运算，而 123 是数字。
即数值之间可以在不同的数据类型之间比较，但是字符串不可以与数值比较。

2.4常用方法

2.4.1 获取字符长度len()

print(len('I like Python!'))
// 输出结果：14

print(len('I like 小明!'))
// 输出结果：10

print(len(''))
// 输出结果：0

print(len(' '))
// 输出结果：1

print(len("\n"))
// 输出结果：1

中文，字母，数字，符号都是占一个长度。
字符串中的空格也是占长度的。
空字符串的长度为0

2.4.2 字符串拼接

a = "Hello"
b = "Python"

print("a   b 输出结果：", a   " "   b)
// a   b 输出结果： Hello Python

2.4.3 重复输出字符串
字符串拼接可以使用符号 * ，示例如下：

print("a * 2 输出结果：", a * 2)
// a * 2 输出结果： HelloHello

2.4.4 通过索引获取字符串中字符
如果把字符串中的每个字符看做在排队的话，那么索引就是这个字符的位置，第一个字符的索引为 0 ，示例如下：

print("a[1] 输出结果：", a[1])
// a[1] 输出结果： e

2.4.5 截取字符串
Python 中则直接使用 [:] 这个表达式即可，遵循 左闭右开 原则，示例如下：

print("a[1:4] 输出结果：", a[1:4])
// a[1:4] 输出结果： ell

从第二个字符到第四个字符

2.4.6 包含
成员运算符 in 可以判断一个字符串种是否包含指定的字符串，并返回 true 或者 false 布尔值。示例如下：

if "H" in a:
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

// H 在变量 a 中

既然有了包含那一定就会有不包含，不包含的成员运算符是 not in ，返回同样是布尔值。示例如下：

if "M" not in a:
    print("M 不在变量 a 中")
else:
    print("M 在变量 a 中")

// M 不在变量 a 中

3.变量基础操作

在 Python 中使用变量，有一个和 Java 最大的不同是无需先声明，直接在赋值的时候就完成了声明。（赋值的时候同时完成声明）

如果我们直接使用一个没有赋值的变量，会直接报错。
正确操作：

name = "小明"

print(name)

// 输出结果：

小明

如果我们对这个变量再次进行赋值，新的赋值将会覆盖之前的赋值。

name = "小红"

print(name)

// 输出结果：

小红

当然，如果我们不再需要这个变量，也可以通过 Python 提供的 del 来删除这个变量。

del name

print(name)

// 输出结果：
Traceback (most recent call last):
  File "D:/Development/Projects/python-learning/base-variable/Demo.py", line 2, in <module>
    print(name)
NameError: name 'name' is not defined

变量类型转换

print('123'   123)

// 输出结果：
Traceback (most recent call last):
  File "D:/Development/Projects/python-learning/base-variable/Demo.py", line 17, in <module>
    print('123'   123)
TypeError: can only concatenate str (not "int") to str

这句报错含义是告诉我们字符串只能连接一个字符串，并不能连接一个整形。

这里我们先写的是字符串，系统默认是做字符串连接操作，但是系统执行到后面发现并不是一个字符串，系统直接就原地炸了

解决方法：
将字符串强成整形，结果会是一个整形
将整形转成字符串，执行字符串拼接操作
当然，这里涉及到了类型强制转换。
float() 函数，将其他类型数据转为浮点数
str() 函数，将其他类型数据转为字符串
int() 函数，将其他类型数据转为整型

print('123'   str(123))

// 输出结果：
123123
#字符串排列
print(int('123')   123)
// 输出结果：
246
#整形相加

那么新的问题来了，如果是一个整形和一个浮点数想加最终会得到什么类型呢？
这里涉及到了一个新的知识点，叫做 类型提升

print(123.5   123)

// 输出结果：
246.5

将字符型转为整形

print(int(123.7))

// 输出结果：
123

直接抹去末尾小数，这里并不会做四舍五入

如果想使用四舍五入的方式，我们还可以借助函数 round() 来实现

print(int(round(123.4)))

// 输出结果：
123

print(int(round(123.5)))

// 输出结果：
124

4.基础运算符

3.1算术运算符

a = 5
b = 10

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)

c = a ** b
print("6. c 的值为：", c)

# 改变 a 和 b 的值

a = 10
b = 5

c = a // b
print("7. c 的值为：", c)

计算结果：

1. c 的值为： 15
2. c 的值为： -5
3. c 的值为： 50
4. c 的值为： 0.5
5. c 的值为： 5
6. c 的值为： 9765625
7. c 的值为： 2

如果是不同类型的数据运算，会发生隐式类型转换。
类型转换的规则由低等向高等转换。
bool（布尔） < int（整形） < float（浮点型） < complex（复数）

a = 1
b = 1.5
c = a   b
print("8. c 的值为：", c, "，c 的类型为：", type(c))

d = True
e = c   d
print("9. e 的值为：", e, "，e 的类型为：", type(e))

f = 2   4j
g = e   f
print("10. g 的值为：", g, "，g 的类型为：", type(g))

计算结果：

8. c 的值为： 2.5 ，c 的类型为： <class 'float'>
9. e 的值为： 3.5 ，e 的类型为： <class 'float'>
10. g 的值为： (5.5 4j) ，g 的类型为： <class 'complex'>

在算术运算时，True代表1，False代表0

4.2 运算内置函数

常用函数事例：

print("11. -1 的绝对值为：", abs(-1))

print("12. 创建的复数为：", complex(1, -2))

print("13. 商和余数为：", divmod(10, 3))

print("14. 浮点型转换：", float(1))

print("15. 10的3次幂为：", pow(10, 3))

print("16. 四舍五入为：", round(5.5))

print("17. 集合求和结果为：", sum({1, 2, 3 ,4}))

print("18. 整数20的二进制为：", bin(20))

print("19. 整数20的八进制为：", oct(20))

print("20. 整数20的十六进制为：", hex(20))

print("21. Unicode 为 97 的字符串：", chr(97))

print("22. 字符串 a 的 Unicode 码：", ord('a'))

print("23. 123 的 boolean 值为：", bool(123))

print("24. 空字符串的 boolean 的值为：", bool(''))

计算结果：

11. -1 的绝对值为： 1
12. 创建的复数为： (1-2j)
13. 商和余数为： (3, 1)
14. 浮点型转换： 1.0
15. 10的3次幂为： 1000
16. 四舍五入为： 6
17. 集合求和结果为： 10
18. 整数20的二进制为： 0b10100
19. 整数20的八进制为： 0o24
20. 整数20的十六进制为： 0x14
21. Unicode 为 97 的字符串： a
22. 字符串 a 的 Unicode 码： 97
23. 123 的 boolean 值为： True
24. 空字符串的 boolean 的值为： False

4.3 比较运算符

a = 5
b = 10

if (a == b):
    print("25. a 等于 b")
else:
    print("25. a 不等于 b")

if (a != b):
    print("26. a 不等于 b")
else:
    print("26. a 等于 b")

if (a < b):
    print("27. a 小于 b")
else:
    print("27. a 大于等于 b")

if (a > b):
    print("28. a 大于 b")
else:
    print("28. a 小于等于 b")

if (a <= b):
    print("29. a 小于等于 b")
else:
    print("29. a 大于  b")

if (b >= a):
    print("30. b 大于等于 a")
else:
    print("30. b 小于 a")

25. a 不等于 b
26. a 不等于 b
27. a 小于 b
28. a 小于等于 b
29. a 小于等于 b
30. b 大于等于 a

4.4赋值运算符

a = 10
b = 20

c = a + b
print("c = a + b 的值为：", c)

c += a
print("c += a 的值为：", c)

c *= a
print("c *= a 的值为：", c)

c /= a
print("c /= a 的值为：", c)

c = 2
c %= a
print("c %= a 的值为：", c)

c **= a
print("c **= a 的值为：", c)

c //= a
print("c //= a 的值为：", c)

c = a + b 的值为： 30
c += a 的值为： 40
c *= a 的值为： 400
c /= a 的值为： 40.0
c %= a 的值为： 2
c **= a 的值为： 1024
c //= a 的值为： 102

4.5 逻辑运算符

and ：逻辑“与”运算符，只有当and两边都是真，结果才是真
or ：逻辑“或”运算符，只要当or一边的是真的，结果就是真
not ：逻辑“非”运算符，反转逻辑值

print(True and True)
# True
print(True and False)
# False
print(True or True)
# True
print(True or False)
# True
print(False or False)
# False
print(not True)
# False
print(not False)
# True

4.6 成员运算符

成员运算符用来判断在指定的序列中有没有找到目标值，这个序列可以是字符串、列表和元祖。

in ： 如果在指定的序列中找到值返回 True，否则返回 False。
not in ： 如果在指定的序列中没有找到值返回 True，否则返回 False。

str = "asdfghjkl"

if 'a' in str:
    print('a 在字符串 str 中')
else:
    print('a 不在字符串 str 中')

if 'a' not in str:
    print('a 不在字符串 str 中')
else:
    print('a 在字符串 str 中')

a 在字符串 str 中
a 在字符串 str 中

a = 20
b = 20

if a is b:
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")

if id(a) == id(b):
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")

# 修改变量 b 的值
b = 30
if a is b:
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")

if a is not b:
    print("a 和 b 没有相同的标识")
else:
    print("a 和 b 有相同的标识")

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

a 和 b 有相同的标识
a 和 b 有相同的标识
a 和 b 没有相同的标识
a 和 b 没有相同的标识

5.基础流程控制

5.1 顺序结构

计算长方形面积：

width = input("请输入长方形的宽：")
height = input("请输入长方形的高：")
area = int(width) * int(height)
print("长方形的面积为：", area)

结果：

请输入长方形的宽：4
请输入长方形的高：5
长方形的面积为：20

5.2 分支结构

if-else结构

weight = input("请输入当前的体重：")

if float(weight) >= 200:
    print("你和加菲猫一样肥！！")
else:
    print("你还是很苗条的么！！")

if-elif-else 判断

weight = input("请输入您当前的体重：")

if float(weight) >= 200:
    print("你和加菲猫一样肥！！")
elif float(weight) >= 100:
    print("你的身材真棒！！")
else:
    print("有点瘦哦，要多吃肉！！")

分支语句嵌套

gender = input("请输入您的性别（M或者F）:")
height = input("请输入您的身高：")

if gender == 'M':
    if float(height) >= 185:
        print("海拔太高了，可能会导致缺氧！！！")
    elif float(height) >= 175:
        print("男神身高！！！")
    else:
        print("哥们，该补钙了！！！")
else:
    if float(height) >= 175:
        print("您可以去当模特了！！！")
    elif float(height) >= 165:
        print("女神身高，您是一位美丽的女孩子！！！")
    else:
        print("美女，多晒晒太阳吧！！！")

5.3 循环结构

正常的while循环

happy = 0

while happy < 10:
    print("学习使我快乐，快乐   1，当前快乐值为：", happy)
    happy  = 1

print("我不快乐了")

运行结果如下：

学习使我快乐，快乐   1，当前快乐值为： 0
学习使我快乐，快乐   1，当前快乐值为： 1
学习使我快乐，快乐   1，当前快乐值为： 2
学习使我快乐，快乐   1，当前快乐值为： 3
学习使我快乐，快乐   1，当前快乐值为： 4
学习使我快乐，快乐   1，当前快乐值为： 5
学习使我快乐，快乐   1，当前快乐值为： 6
学习使我快乐，快乐   1，当前快乐值为： 7
学习使我快乐，快乐   1，当前快乐值为： 8
学习使我快乐，快乐   1，当前快乐值为： 9
我不快乐了

while死循环

happy = 0

while True:
    print("学习使大佬快乐，快乐   1，当前快乐值为：", happy)
    happy  = 1

for循环

for <variable> in <sequence>:
    <statements>
else:
    <statements>

举例：

for index in "Python":
    print(index)

P
y
t
h
o
n

这里相当于去循环 “Python” 这个字符串里的每位字符。
如果需要使用 for 循环遍历数字序列，可以使用内置的 range() 函数。先简单体验下：

for index in range(5):
    print(index)

0
1
2
3
4

语法：range(start, stop[, step])
start：计数从 start 开始。
stop：计数到 stop 为止，但不包括 stop 。
step：步长，也叫间隔。

举例：从0开始，到10结束（不包括10），间隔为3👇

for index in range(0, 10, 3):
    print(index)

0
3
6
9

循环中断：
在 Python 中，中断循环有 break 和 continue 两种。

break ：结束本次循环，跳出所在的循环。
continue ：中断本次循环，继续进行下一次循环。

e.g.那么如果你去开黑，不回来学习了就是 break 。

happy = 0

while happy < 10:
    happy  = 1
    if happy == 5:
        break
    print("学习使我快乐，快乐   1，当前快乐值为：", happy)

print("还是开黑更快乐一些~~~")

学习使我快乐，快乐   1，当前快乐值为： 1
学习使我快乐，快乐   1，当前快乐值为： 2
学习使我快乐，快乐   1，当前快乐值为： 3
学习使我快乐，快乐   1，当前快乐值为： 4
还是开黑更快乐一些~~~

当然，有时候也会有些特殊情况，比如开黑玩了一局以后，还是觉得学习更快乐，接着回来学习：

happy = 0

while happy < 10:
    happy  = 1
    if happy == 5:
        continue
    print("学习使我快乐，快乐   1，当前快乐值为：", happy)

print("还是学习会更快乐~~~")

学习使我快乐，快乐   1，当前快乐值为： 1
学习使我快乐，快乐   1，当前快乐值为： 2
学习使我快乐，快乐   1，当前快乐值为： 3
学习使我快乐，快乐   1，当前快乐值为： 4
学习使我快乐，快乐   1，当前快乐值为： 6
学习使我快乐，快乐   1，当前快乐值为： 7
学习使我快乐，快乐   1，当前快乐值为： 8
学习使我快乐，快乐   1，当前快乐值为： 9
学习使我快乐，快乐   1，当前快乐值为： 10
还是学习会更快乐~~~