这里是佳奥！让我们从一个demo继续python的学习。

##this is a demo
a = 10
if a >= 0:
    print (a)
else:
    print (-a)
    
PS D:\work> & D:/Programe/python/python.exe d:/work/test.py
10

#是注释。

当语句以冒号:结尾时，缩进的语句视为代码块。

按照约定俗成的惯例，应该始终坚持使用4个空格的缩进。

Python程序是大小写敏感的。

1 数据类型和变量

数据类型：整数、浮点数（小数）、字符串。

I'm "ok" : 
print( 'I \'m \"ok\"')

##转义字符 \
\n：换行
\t：制表符，产生四个孔空字符
\\：\
r''：默认不转义
''' '''：表示多行内容

print('1\n1')
1
1

print('1\t1')
1       1

print('1\\1')
1\1

print(r'1\n1')
1\n1

print('''this is line 1
this is line 2
this is line 3''')
this is line 1
this is line 2
this is line 3

布尔值：

print(True)
True

print(3 > 5)
False

##布尔值可以用and、or和not运算

and运算：与运算
or运算：或运算，含有True结果就是True
not运算：非运算

print(True and False)
False

print(True or False)
True

print(False or False)
False

print( 5 > 3 or 1 > 3)
True

print(not True)
False

空值

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

变量

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头。

变量a是一个整数
a = 1

变量b_2是一个字符串
b_2 = 'second'

变量C是一个布尔值
C = True

##在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

a = 16
print(a)

a = 'Next'
print(a)

a = False
print(a)

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言(Java)。

##请不要把赋值语句的等号等同于数学的等号。
x = 10
x = x + 2
print(x)
12

##变量指向
a = 'ABC'
b = a
a = 'XYZ'
print(b)
ABC

常量

不能变的变量，比如常用的数学常数π就是一个常量。

整数的除法为什么也是精确的：

print(9 / 3)
3.0

print(10 / 3)
3.3333333333333335

##// 地板除，整数的地板除//永远是整数，即使除不尽
print(10 // 3)
3

##余数运算，可以得到两个整数相除的余数
print(10 % 3)
1

2 字符串和编码

需要了解下面三种编码：

Python的字符串：在最新的Python 3版本中，字符串是以Unicode编码的

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

print(ord('中'))
20013

print(chr(25991))
文

为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

格式化

在Python中，采用的格式化方式和C语言是一致的，用%实现：

print('Hi, %s, you have $%d.'%('Tom', 10000))
Hi, Tom, you have $10000.

常见的占位符有：

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

print('Date %s, Day %s'%(16, 'Tuesday'))
Date 16, Day Tuesday

需要包含字符%，转义：

print('growth rate: %d %%'%7)
growth rate: 7 %

format()

另一种格式化字符串的方法是使用字符串的format()方法：

print('Hello, {0}, 衬衫的价格是 {1:.1f}'.format('小明', 9.15))
Hello, 小明, 衬衫的价格是 9.2

f-string

最后一种格式化字符串的方法是使用以f开头的字符串，称之为f-string：

r = 2.5
s = 3.14 * r **2
print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

上述代码中，{r}被变量r的值替换，{s:.2f}被变量s的值替换，并且:后面的.2f指定了格式化参数（即保留两位小数），因此，{s:.2f}的替换结果是19.62。

练习

小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出'xx.x%'，只保留小数点后1位：

y1 = 72
y2 = 85
improve = ( y2 - y1 )*100/y2
print(f'This year, XiaoMing\'s grade is {y2}, rise is {improve:.1f}%')
This year, XiaoMing's grade is 85, rise is 15.3%

3 使用list和tuple

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

namesdata = ['Michale','Bob','Anyone']

变量classmates就是一个list。用len()函数可以获得list元素的个数：

print(len(namesdata))
3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

print(namesdata[0])
Michale

##以此类推

当索引超出了范围时，Python会报一个IndexError错误，最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，可以用-1做索引，直接获取最后一个元素：

print(namesdata[-1])
Anyone

##以此类推

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

namesdata.append('This name is added')

print(namesdata)
['Michale', 'Bob', 'Anyone', 'This name is added']

也可以把元素插入到指定的位置，比如索引号为1的位置：

namesdata.insert(1,'The position is 1')

print(namesdata)
['Michale', 'The position is 1', 'Bob', 'Anyone']

要删除list末尾的元素，用pop()方法：

print(namesdata)
namesdata.pop()
print(namesdata)

['Michale', 'Bob', 'Anyone']
['Michale', 'Bob']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

print(namesdata)
namesdata.pop(1)
print(namesdata)

['Michale', 'Bob', 'Anyone']
['Michale', 'Anyone']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

print(namesdata)
namesdata[1]='Sam'
print(namesdata)

['Michale', 'Bob', 'Anyone']
['Michale', 'Sam', 'Anyone']

list里面的元素的数据类型也可以不同。

list元素也可以是另一个list：

a = ['first','second','third']
b = ['1','2',a,'3']
print(b)

['1', '2', ['first', 'second', 'third'], '3']

如果一个list中一个元素也没有，就是一个空的list，它的长度为0。L=[ ]，len(L)结果为0。

tuple

另一种有序列表叫元组：tuple。tuple一旦初始化就不能修改。

namesdata = ('Michale', 'Bob', 'Anyone')

namesdata这个tuple不能变了，它也没有append()，insert()这样的方法。

其他获取元素的方法和list是一样的，namesdata[0]，classmates[-1]，但不能赋值成另外的元素。

要定义一个只有1个元素的tuple，必须加一个逗号,，来消除歧义：

t = (1,)
print(t)

(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免误解成数学计算意义上的括号。

“可变的”tuple：

t = ('a','b',['A','B'])
t [2][0]='C'
t [2][1]='D'
print(t)

('a', 'b', ['C', 'D'])

理由就是，t是一个tuple，但其中包含一个可以改变的list。

要创建一个内容也不变的tuple，就必须保证tuple的每一个元素本身也不能变。

练习

请用索引取出下面list的指定元素：

L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]

##打印Apple:
print(L[0][0])
##打印Python:
print(L[1][1])
##打印Lisa:
print(L[2][2])

4 条件判断

输入用户年龄，根据年龄打印不同的内容：

age = 20
if age >= 18:
    print('your age is:',age)
    print('adult')

给if添加一个else语句：

age = 2
if age >= 18:
    print('your age is:',age)
    print('adult')
else:
    print('your age is:',age)
    print('permission denined')

上面的判断是很粗略的，完全可以用elif做更细致的判断：

age = 2
if age >= 18:
    print('your age is:',age)
    print('adult')
elif age >=6:
    print('your age is:',age)
    print('teenager')
else:
    print('Hey,kid')

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else：

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

##打印出的结果是teenager

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False：

if x:
    print('True')

练习

小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

• 低于18.5：过轻
• 18.5-25：正常
• 25-28：过重
• 28-32：肥胖
• 高于32：严重肥胖

用if-elif判断并打印结果：

height = 1.75
weight = 80.5
BMI = weight / (height **2)

if BMI < 18.5:
    print('过轻')
elif BMI < 25:
    print('正常')
elif BMI < 28:
    print(f'BMI为:{BMI:.1f},过重')
elif BMI < 25:
    print('肥胖')
else:
    print('严重肥胖')

BMI为:26.3,过重

5 循环

for in

Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来：

names = ['Michael','Bob','Tom']
for name in names:
    print(name)

Michael
Bob
Tom

我们想计算1-10的整数之和，可以用一个sum变量做累加：

sum = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
    sum = sum + x
print(sum)

55

如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list：

print(list(range(5)))
[0, 1, 2, 3, 4]

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

5050

while

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。

比如我们要计算100以内所有奇数之和，可以用while循环实现：

sum = 0
n =99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

2500

在循环内部变量n不断自减，直到变为-1时，不再满足while条件，循环退出。

练习

请利用循环依次对list中的每个名字打印出Hello, xxx!：

L = ['Bart', 'Lisa', 'Adam']

L = ['Bart', 'Lisa', 'Adam'] 
for names in L:
    print('Hello,%s!'%names )

Hello,Bart!
Hello,Lisa!
Hello,Adam!

break

在循环中，break语句可以提前退出循环。

n = 1
while n <= 100:
    if n > 10: ##当n = 11时，条件满足，执行break语句
        break ##break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

continue

在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

只打印奇数，可以用continue语句跳过某些循环：

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: ##如果n是偶数，执行continue语句
        continue ##continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

1
3
5
7
9

有些时候，如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。

试写一个死循环程序：

n = 1
while n > 0:
    n = n + 1
print(n)

6 使用dict和set

dict

Python内置了字典：dict的支持。

假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩：

d = {'Michael':95,'Bob':75,'Tom':85}
print(d['Michael'])

95

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

d['Tom']=80
print(d['Tom'])

80

由于一个key只能对应一个value，多次对一个key放入value，后面的值会把前面的值冲掉。

为避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

print('Tom' in d )

True

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

注意：返回None的时候Python的交互环境不显示结果。

print(d.get('Toom',25) )

25

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

print(d)
d.pop('Tom')
print(d)

{'Michael': 95, 'Bob': 75, 'Tom': 85}
{'Michael': 95, 'Bob': 75}

dict是用空间来换取时间的一种方法。

需要牢记的第一条就是dict的key必须是不可变对象。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

set

set和dict类似，也是一组key的集合，但不存储value。

key不能重复，在set中没有重复的key。

创建一个set，需要提供一个list作为输入集合：

s = set([1,2,3])
print(s)

{1, 2, 3}

传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素。

重复元素在set中自动被过滤：

s = set([1,2,2,3,3])
print(s)

{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

s.add(4)
print(s)

{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

s.remove(4)
print(s)

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

s1 = set([1,2,3,4])
s2 = set({3,4,5,6})

print(s1 & s2)
print(s1 | s2)

{3, 4}
{1, 2, 3, 4, 5, 6}

set和dict的唯一区别仅在于没有存储对应的value，同样不可以放入可变对象。

试试把list放入set，看看是否会报错：

b = [1,2,3]
s2 = set({3,4,b,6})
print(s2)

ypeError: unhashable type: 'list'

再议不可变对象

上面我们讲了，str是不变对象，而list是可变对象。

a = ['c','b','a']
a.sort()
print(a)

['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作：

a = 'abc'
b = a.replace('a','A')
print(a)
print(b)

abc
Abc

要始终牢记的是，a是变量，而'abc'才是字符串对象。

我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回。便是b。

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回。

python基础内容学到这里。

下一篇我们继续函数的学习。

我们下一篇再见！