一、Python基础之数据类型与变量 朝

一、运行第一个Python程序

在项目根目录下新建一个py文件，取名study01

输入代码：
print("Hello World!")

在py文件上右键，点击Run+"文件名" 来运行程序

代码执行完毕，在PyCharm的界面下方Run窗口中会出现执行结果，这里print打印了"Hello, Python!"，exit code 0代表程序顺利执行完毕，正常退出；

二、输入与输出

print( )函数用于在屏幕上打印输出内容
print( )输出，括号中的内部，就是需要输出内容，如果括号中是字符串，那输出的就是一个字符串

>>> print("Hello, world!")
>>> Hello, world!

也可以输出多个字符串，用逗号隔开，实现连成一串输出
>>> print("Hello","world","I'am","study","python")
Hello world I'am study python

如果需要用户输入一些字符给python程序处理怎么办？
python提供一个input( )函数，可以让用户输入字符串，并放入一个变量中，供程序使用
>>> name = input()
>>> print(name)

在IDE中输入 name = input( ) 并执行，在执行结果Run标签栏中就会等待你输入了，输入完并回车后，输入的字符就存入变量name中，此时执行 print(name) 就会输出刚才输入的字符

但上面虽然实现了数据的输入与输出，但从用户体验上讲很不友好，因为缺乏基本的提示与交互，因此可以这样改造
>>> name = input("请输入你的名字：")
>>> print("你输入的名字是："，name)

在 input( ) 函数的（ ）中可放入需要展示的字符
任何计算机程序都是为了执行一个特定的任务，有了输入，用户才能告诉计算机程序所需的信息，有了输出，程序运行后才能告诉用户任务的结果。
输入是Input，输出是Output，因此，我们把输入输出统称为Input/Output，或者简写为IO

三、变量/常量

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
a = 5 # 此时a的值是5是一个整数
print("a:",type(a))
a = 6 # 此时a的值是6是一个整数
print("a:",type(a))
b = 'abcd' # 此时b是一个字符串'abcd'
print("b:",type(b))
b = True # 此时b是一个布尔值True
print("b:",type(b))

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量
变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错，例如Java是静态语言，赋值语句如下

int a = 10; // 声明a是整数类型，并把10赋值给变量a
a = "xyz"; // 编译会报错，因为a为整数类型变量，"xyz"为字符串，数据类型不同

相比之下 ，动态语言更加灵活方便
问题：

x = 5
x = x+10
print(x)

打印输出 x 的值是多少？
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量

PI = 3.14159265

虽然PI定义为常量，实质上在python中，PI仍旧可被再次赋值，因为把常量用大写标识区分是一种习惯性用法以提示开发者不要随意去改变这个值，Python没有任何机制保证PI不会被改变

四、Python的数据类型

整数、浮点数、字符串、布尔值、空值、列表、字典、元祖、集合
整数 int类型（包含负整数）
整数表示方法在程序中与数学上的写法一模一样，如：1，10，200，-55，0等等

>> a = 10
>> b = 230
>> c = 1
>> d = 0
>> e = -22
>> f = 100000000
此时a,b,c,d,e,f都是int类型即整数

通过 type( ) 函数可查看该变量属于什么类型
a = 10
print(type(a))
<class "int">

浮点数 float
浮点数也就是小数，如：3.14, 0.0001, -1.23，0.00 等

>> a = 3.14
>> b = 0.00001
>> c = -1.23
>> d = 0.00
>> print("a的数据类型：",type(a))
>> print("b的数据类型：",type(b))
>> print("c的数据类型：",type(c))
>> print("d的数据类型：",type(d))
a的数据类型： <class 'float'>
b的数据类型： <class 'float'>
c的数据类型： <class 'float'>
d的数据类型： <class 'float'>

字符串 str
字符串是以单引号'或双引号"括起来的任意文本，比如'你今日学习了吗？'，"xyz"等等，注：单引号/双引号，只是字符串的表达方式，字符串中的字符不包含单双引号

>> s1 = "abc" # 字符串s1中的字符是：a,b,c
>> s2 = "I'm good" # 字符串s2中的字符是：I,',m,空格,g,o,o,d
>> s3 = " " # 字符串s3中的字符是：空格，空格，空格

只在被单/双引号包含的所有形式的字符都属于字符串
>> s4 = '123xyu'
>> s5 = "?><>' 1234abcds,这是中文"
>> print(type(s4))
>> print(type(s5))
<class 'str'>
<class 'str'>

问题：如何打印字符串：I'm "Jie"!
>> a = 'I\'m \"Jie\"!'
>> print(a)
I'm "Jie"!

可以用转义字符来标识，转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\

布尔值 bool
一个布尔值只有True、False两种值
在Python中，可以直接用True、False表示布尔值（请注意大小写）

>> Ture
Ture
>> False
False
>> 2>1
True
>> 3>5
False

布尔值可结合and、or和not运算。
and 与运算，只有所有都为 True ，and运算结果才是 True

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 3>2 and 3>1
True
>>> 3>2 and 3>4
False

or 或运算，只要其中有一个为 True，or运算结果就是 True

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 3>2 or 3>1
True
>>> 3>2 or 3>4
True

not 非运算，把 True 变成 False，False 变成 True

>>> not True
False
>>> not False
True

布尔经常结合条件判断使用

if age>=18:
    print("成年人")
else:
    print("未成年")

空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

列表 list
Python内置的数据类型，List是一种有序的集合，可以随时添加和删除列表中的元素（类似与一种数据容器）

names = ['Jie','Anna','Jack','Flask','Rury'] # 列表以[]标识，列表中的元素以,来划分
list1 = ['abc',133,0.123,[12,"xyz"],True] # 列表中可以存放任意数据类型

len( ) 函数可以返回一个列表的长度，即元素个数

>>> a = len(names)
>>> print(a)
5
>>> b = len(list1)
>>> print(b)
5

索引
通过索引可读取列表中指定的元素，注：列表中索引从0开始

>>> print(names[0])
Jie
>>> print(names[1])
Anna
>>> print(names[2])
Jack
>>> print(names[3])
Flask
>>> print(names[4])
Rury
>>> print(names[5]) # 当索引超出范围时，就会报错
IndexError: list index out of range

运用索引去获取列表中的元素时，注意不要越界，最后一个元素的索引是 len(list) -1
倒序索引

>>> print(names[-1])
Rury
>>> print(names[-2])
Flask
>>> print(names[-3])
Jack
>>> print(names[-4])
Anna
>>> print(names[-5])
Jie
>>> print(names[-6]) # 当索引超出范围时，就会报错
IndexError: list index out of range

append( ) 函数，可以往list末尾追加元素

>>> names = ['Jie','Anna','Jack','Flask','Rury']
>>> names.append('Joy')
>>> print(names)
['Jie','Anna','Jack','Flask','Rury','Joy']

insert( ) 函数，可以把元素插入到指定的位置

>>> names.insert(1,"Bory") # 把"Bory"插入到列表索引为1的位置
>>> print(names)
['Jie', 'Bory', 'Anna', 'Jack', 'Flask', 'Rury', 'Joy']

pop( ) 函数，取出列表末尾元素，并删除

>>> names = ['Jie','Anna','Jack','Flask','Rury','Joy']
>>> name = names.pop() # 取出列表最后一个元素 'Joy',并从列表中删除
>>> print(name)
>>> print(names)
Joy
['Jie', 'Anna', 'Jack', 'Flask', 'Rury']

pop(i) 取出列表中指定索引的元素，并删除

>>> names = ['Jie','Anna','Jack','Flask','Rury','Joy']
>>> name = names.pop(3) # 取出列表索引为4的元素 'Flask',并从列表中删除
>>> print(name)
>>> print(names)
Flask
['Jie', 'Anna', 'Jack', 'Rury', 'Joy']

列表中替换某一元素，可通过直接赋值

>>> names = ['Jie','Anna','Jack','Flask','Rury','Joy']
>>> names[2] = 'Jocy' # 替换 'Jack' 为 'Jocy'
>>> print(names)
['Jie', 'Anna', 'Jocy', 'Flask', 'Rury', 'Joy']

元祖 tuple
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

citys = ('上海','北京','西安','酒泉','杭州','苏州') # citys元组一旦被定义即已确定，无法被修改

因此 tuple 类型，没有append( ), insert( ), pop( )方法以及对元素重新赋值，相对list来说，tuple的不变特性，可使代码更安全
定义只有一个元素的 tuple

>>> t1 = (1)
>>> t2 = (1,)
>>> print(t1,type(t1))
>>> print(t2,type(t2))
1 <class 'int'>
(1,) <class 'tuple'>

（）既可表示tuple，又可能表示数学公式中的（），因此为了区分不同解决歧义，Python语法规定，当tuple只有一个元素时，必须 加一个逗号, 来区分数学上的（）

字典 dict
字典使用键-值对存储（key-value），具有极快的查找速度，其他语言中称map

>>> score = {"小明":90, "李刚":85, "张强":78} 
>>> print(score["李刚"])
85

把数据存入已定义的字典

>>> score['赵钱']=88
>>> print(score)
{"小明":90, "李刚"：85, "张强":78,"赵钱":88}

修改字典中key对应的值

>>> score['赵钱']=100
>>> print(score)
{"小明":90, "李刚"：85, "张强":78,"赵钱":100}

在字典中，key必须是唯一的不重复，如果key不存在，则会抛出错误

>>>print(score['张亮'])
KeyError: '张亮'

为了避免不必要的异常，获取字典中的value，可通过get( )函数，如果没有这个key，则返回None，也可指定返回

>>> score = {"小明":90, "李刚":85, "张强":78} 
>>> print(score.get("小明"))
90
>>> print(score.get("兰陵王"))  # key不存在，则默认返回None
None
>>> print(score.get("兰陵王",0)) # key不存在，则返回指定数据0
0

注：字典中的key必须是一个不可变对象，在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

集合 set
集合与字典类似，但集合是key的集合，不储存value，同样集合中的元素唯一

>>> s1 = set([1,'a',2,'b'])
>>> print(s)
{1, 2, 'b', 'a'}

重复元素在集合中被过滤

>>> s2 = set([1,1,2,'a','a'])
>>> print(s2)
{1, 2, 'a'}

在集合中添加元素 add(key)

>>> s2.add(3)
>>> print(s2)
{1, 2, 'a', 3}

在集合中删除元素remove(key)

>>> s2.remove(3)
>>> print(s2)
{1, 2, 'a'}

格式化
我们在输出字符串时经常需要格式化输出，例如：“你好xxx，你的订单xxxxxxxxx已经发货！”这个字符串中的xxxx就需要通过变量格式化输出
在python中通过 % 来格式化输出，在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%占位符，后面就跟几个变量或者值，顺序要对应好

>>> print("Hello, %s" % "Jie")
Hello, Jie
>>> print("你好%s,祝你永远%d岁!"%("Jie",18))
你好Jie,祝你永远18岁!
>>> print("你输入的金额是：%.2f" % 1.78) # 保留2位小数
你输入的金额是：1.78

通过变量格式化输出

>>> a = "Jack"
>>> print("Hello, %s!" % a)
Hello, Jack!

占位符	替换内容
%f	浮点数
%s	字符串
%d	整数
%s	字符串
%x	十六进制整数

通过format( )格式化字符串

>>> print("你好{}，你的订单{}已经发货！".format("Jie",158372858928))
你好Jie，你的订单158372858928已经发货！
>>> print("你好{1}，你的订单{0}已经发货！".format(158372858928,"Jie")) # 在占位符{}中添索引，对应format中的字符
你好Jie，你的订单158372858928已经发货！

f-string 格式化字符串
以 f 开头的字符串，字符串中如果包含{xxx}，就会用对应xxx变量替换

>>> a = "Jie"
>>> print(f"你好，{a}!")
你好，Jie！
>>> p = 3.1415926
>>> print(f"圆周率为{p:.2f}") # {p:.2f}被变量p代替，并且:后面的.2f指定了格式参数，即保留2位小数
圆周率为3.14

Python常用运算符
数学运算符（+，-，*，/, %, //, **)

>>> a = 5
>>> b = 3
>>> print(a+b) # 加法，两数这和
8
>>> c = "abc"
>>> d = "xyz"
>>> print(c+d) # 字符串拼接
"abcxyz"
>>> print(a-b) # 减法，两数之差
2
>>> print(a*b) # 乘法，两数之积
15
>>> print(a/b) # 除法，两数之商
1.6666666666666667
>>> print(a%b) # 取余, 返回余数
2
>>> print(a//b) # 取整除，返回商整数部分（向下取整）
1
>>> print(a**b) # 幂运算
125

赋值运算符（=， +=， -=， *=， /=，%=，**=，//=）

>>> a = 10  # 将整数10赋值给变量a
>>> b = 21
>>> c = 0
>>> c = a + b # 将a+b 赋值给变量c
>>> c += 1 # 加法赋值运算，c = c+1
>>> a -= 1 # 减法赋值运算，a = a-1
>>> a *= 10 # 乘法赋值运算，a = a*10
>>> a /= 10 # 除法赋值运算，a = a/10
>>> a %= 10 # 取模赋值运算，a = a%10
>>> a **= 10 # 幂赋值运算，a = a**10
>>> a //=10 # 取整除赋值运算，a = a//10

比较运算符（==，!=，>，<，>=，<=）

>>> a = 10
>>> b = 20
>>> a == b # 等于，比较对象是否相等，返回布尔值
False
>>> a != b # 不等于，比较两对象是否不相等，返回布尔值
True
>>> a > b # 大于，返回布尔值
False
>>> a < b # 小于，返回布尔值
True
>>> a >= b # 大于等于，返回布尔值
False
>>> a <= b # 小于等于，返回布尔值
True

比较运算符在条件判断中有重要作用
逻辑运算符（and，or，not）

>>> a = 10
>>> b = 5
>>> a>3 and a>b # 与运算，and两边都为真时返回True，有一个为False则返回False
True
>>> a>20 or b>b # 或运算，or两边只要有一个为真，则返回True
True
>>> not a>20 # 非运算，not后面如果为True,则返回False,如果为False，则返回True
True