python入门篇：基本语法

第一个程序：helloworld！

helloworld几乎是我们学习所有语言开始的第一个程序。
python如何去实现输出helloworld呢？

print("helloworld")

不用printf！不用%s！不用分号！不用头文件！不用return 0 ！不用大括号！
输入好之后，就可以运行。

python语法 - 基本数据类型

既然已经尝试了输出，我们当然还希望操作python的数据。下面我们就开始基本数据类型的学习。

1.1 变量的定义

变量的类型不需要声明，使用的时候可以直接命名。
比如那我们刚刚的程序，我们在helloworld的输出下面加一行

a = 4

然后我们对他进行输出（ 不需要%d，不需要分号都可以不需要）

print(a)

就可以看到，程序正确的输出了4。
python语言变量不需要提前声明，也就是说，python语言中变量的类型是没有规定的。
上一秒a还是整形，下一秒可以直接用字符串来赋给他，a就变成了一个字符串类型。

print("helloworld")
a = 4
print(a)
a = "helloworld"
print(a)

输出为：
helloworld
4
helloworld

但是，这样方便的python同样有要求：那就是使用变量之前必须对该变量进行赋值。没有赋值直接使用是不被允许的。
但是没有赋值，却用变量直接承接表达式是被允许的。

a = 4
b = 3
c = a + b
# 没有对c进行初始化的情况下直接进行c = a + b 是允许的
# 井字号是python的单行注释方法

1.2 连续赋值

python可以接受同时多个变量的赋值：

x, y, z = 1, 2, 3
a = b = 123

# 都是python语言允许的定义

1.3 python的基本输入和输出

python的输出：print即可。print函数可谓来者不拒，不论要输出整形浮点型双精度字符串列表集合等等等等，只要是变量，统统丢到函数当中即可。

数值类型可以直接输出

#
print(1) 

字符串类型可以直接输出

#python的字符串表达也非常简单，但凡是用引号括起来的内容都是字符串，都可以随意输出。
print("Hello World") 
#python中，为了方便输入输出的内容带引号，字符串的定义有四种方式：
a = "i love python!"
a = 'really!'
a = '''learning python is good for my hair!''' 
a = """人生苦短，我学python"""

一次输出多个对象，对象之间用逗号分隔

a=1
b="Hello World"
print(a, b)

如果直接输出字符串，而不是用对象表示的话，可以不使用逗号

print("Duan""Yixuan")
print("Duan","Yixuan")
#运行结果如下：
#DuanYixuan
#Duan Yixuan
#可知，不添加逗号分隔符，字符串之间没有间隔

设置间隔符sep

print("www", "snh48", "com", sep=".")  # 设置间隔符
#运行结果如下：
#www.snh48.com

python的输入同样非常简单，只需要input即可。不论输入符号，数字，字母，都是允许的。

x = input()

设置两个整数变量a，b；键盘输入a，b的值，打印出a+b
输入：4 4
输出：4+4=8

a=input()
b=input()
c=a+b
print(a,'+',b,'=',c)

这时候输入4 4，打印的结果是4+4=44，这是为什么呢？
注意：这里input的所有内容都是字符串类型。

print(type(x)) # 输出x的类型。结果为：<class 'str'>

如果我们想进行“输入x，计算x的平方”的程序应该怎么做呢？
这里提供两种方法：

# 1.对x进行强制转换 ： 
x = input()
x = int(x) * int(x)
print(x)

# 2.对输入的内容进行去引号处理
x = input()
# eval去引号函数      在把引号去掉赋给变量之前，还会自动的根据括号的内容对变量的类型进行分配
print(type(eval(x)))
x = eval(x) * eval(x)
print(x)
# 如果输入 5，则会输出 int；如果输入 5.5， 则会输出  float；如果输入[1， 2， 3]，就会输出 list，等等
# 然而eval并不能拆字符串

两种方法都可以使用，但是我们平时使用eval函数更多一点
练习

a=input()
b=input()
c=eval(a)+eval(b)
print(a,'+',b,'=',c)

1.3.1 输入输出语句格式拓展

1. python允许在input括号内通过加字符串的格式来对输入内容进行描述

x = input("please input a integer:")
print(x)

1. python的print输出函数自动计入回车。取消回车的方式是：

print("I don't want an enter",end='')
print("no enter")
# 实际上，end=做的事情是将等号后面的字符串加到每一次输出的末尾，默认为回车。

1. 此下，给出了其他可用的输出格式，大家课后自己学习

#将输出内容用双引号括起来，变量用{}来表示，双引号后调用format函数,format中变量用，隔开。
print("{} is a pig,{} is niubi".format("XXX","XXX"))  # 这样输出时，大括号的顺序和format顺序一一对应
print("{1} is a pig,{0} is niubi".format("XXX","XXX"))  # 这样输出时，大括号顺序按照填写内容进行对应
print("{:.2f}".format(12345.6789)) #format格式打印 小数点后2位
print("{:20f}".format(12345.6789)) #format格式打印 占20位字符

#1.填充对齐宽度
print("{0:~^20}".format(bstring))
#print("{0:           =        ^      20}".format("bstring"))      ^居中，>右对齐，<左对齐
   #      |           |         |      |       |      |
   #     引导符     填充物      居中   宽度    格式化  目标字符串
print("{0:*>20}".format("bit"))
print("{:20}".format("aa"))  # 将aa放于左边，自动补齐剩余空格
# 2.逗号(千分符，用于财务记账)   点精度(浮点数小数精度或字符串最大输出长度，{:.2f})
#   类型
print("{:,.2f}".format(12345.6789))    # 1 .整数部分放置千分符分割；2.精度补为两位

print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))  # 用二进制，Unicode编码，十进制，八进制，大小写十六进制表示括号内的数值

print("{0:e},{0:E},{0:f},{0:%}".format(3.14))  # 用小写大写的科学记数法表示，用通常的浮点数表示，用百分数表示

python语法 - 分支语句，循环语句

2.1 分支语句

在进行python程序的编写时，应该格外注意格式的书写。
因为python是没有大括号的语言，所以能够判断python语段范围的只有缩进。
python的分支表达式为：

if <语句段>:
	# 必须缩进，否则会报错。而且只能缩进一次
	<语句段>

age=int(input("请输入你的年龄:"))
if 0<=age<6:
    print("at a kindergarten")
elif 6<=age<=12:
    print("at primary school")
elif 12<age<=15:
    print("at a junior school")
elif 15<age<=18:
    print("at a high school")
else:
    print("be an adult")

我们来小小的实践一下：
判断输入是否是偶数

a = eval(input())
if a % 2 == 0 :
	print('yes!')
elif a % 2 == 1:
	print('no!')
# 或者也可以直接else：

2.2for循环语句

与分支语句相同，循环语句中的缩进同样非常重要。
python的循环表达式为：

for <循环判断>:
	# 必须缩进，否则会报错。而且只能缩进一次
	<语句段>

其中，循环判断的格式为：

	i in <范围>

只要是能够进行循环遍历操作的，都用 i in … 来修饰即可
这个范围可以是一个列表（相当于c语言的数组）：

list = [1, 2, 3]
for i in list:
	print(i)
	# 则i会遍历整个列表

也可以是一个整数：

for i in range(45):# 则i会分别被赋值为0， 1， ...， 44
	print(i,end='  ')	

range函数
range(start, stop[, step])

range(10) # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(1, 11) # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(0, 30, 5) # 步长为 5
[0, 5, 10, 15, 20, 25]
range(0, -10, -2) # 负数
[0, -2, -4, -6, -8]

for i in range(10) :
    print(i)
for i in range(2, 10) :
    print(i)
for i in range(0, 10, 2) :
    print(i)
for i in range(0,-10,-2) :
    print(i)

2.3 while循环语句

打印1到10的数字

x=1
while x<=10:
	print(x,end=' ')
	x+=1

练习
求1-2+3-4+5 … 99的所有数的和

s=0
for i in range(100) :
   if i % 2 ==0 :
       s-=i
   else:
       s+=i
print(s)

python语法 - 组合数据类型

3.1 集合

python的集合概念与数学概念上的集合非常相像，就是一群有相同意义的数据的集合。在python中常用于数据去重。
python的语法表达中，集合的表达形式为：大括号{}

b = 2
a = {1, 'python', b}
# 集合来者不拒，大多数数据类型都可以直接包含到集合当中

集合中不能有相同的元素.如果出现相同的元素，集合会直接将相同的其他项删除，只保留一项。而且，当集合中包含变量时，集合会直接判断变量的内容是否与集合内容重复。集合没有顺序

以下给出集合的操作，同学们课后掌握

#-------------------------集合操作符-------------------------#
c = {1,2,3,4,5} ; d = {4,5,6,7,8}
#1.求并集: |
print('1.1 ',c|d)
#2.求集合的差(取前不取后): -
print('1.2 ',c-d)   #输出包含在c中但不在d中的元素
#3.求交集: &
print('1.3 ',c&d)
#4.求两集合中不同的元素: ^
print('1.4 ',c^d)
#5.比较两个元素的包含关系
print('1.5 ',c>=d)
e = {1,2,3}
print('1.6 ',c>=e)
#-------------------------增强操作符-------------------------#
c |= d  #更新集合c，包括c，d中的所有元素
print('2.1 ',c)
c -= d  #同上，讲c，d运算过后的结果赋值给c
print('2.2 ',c)

#------------------------集合处理方法------------------------#
c = {1,2,3,4,5}
#!! 1.如果x不在集合中，将x增加到c
c.add(6)
print('3.1 ',c)

c = {1,2,3,4,5}
#!! 2.如果x在集合中，移除x; 如果x不在集合中，不报错
c.discard(5)
print('3.2 ',c)

c = {1,2,3,4,5}
#!! 3.如果x在集合中，移除x;如果x不在集合中，报错
c.remove(5)
print('3.3 ',c)

c = {1,2,3,4,5}
#!! 4.移除所有元素
c.clear()
print('3.4 ',c)

c = {1,2,3,4,5}
#5.为用户随即返回一个集合中的元素并且在几何中删除这个元素。如果集合为空则报错
f = c.pop()
print('3.5 ',f,c)

c = {1,2,3,4,5}
#6.返回一个集合的副本
d = c.copy()
print('3.6 ',d)

c = {1,2,3,4,5}
#!! 7.返回集合元素个数
f = len(c)
print('3.7 ',f)

c = {1,2,3,4,5}
#!! 8.判断x是否在集合中
a = 5 in c
print('3.8 ',a)

c = {1,2,3,4,5}
#9.判断x是否不在集合中
a = 5 not in c
print('3.9 ',a)

c = (1,2,3,4,5,5,5)
#10.将其他类型转化为集合类型
c = set(c)
print('3.10 ',c)

练习
集合a={5，6，4，8，9}
b，c为两个变量，用户输入决定其内容
将b添加到集合a中，如果集合a中包含变量c，将c从集合a中删除

a = {1,2,3,4,5}
b=input("请输入b的值")
c=input("请输入c的值")
a.add(eval(b))
a.discard(eval(c))
print(a)

3.2 列表

列表的概念非常接近于我们C/C++中的数组。它的内容可以重复，有固定的顺序。列表定义只需要中括号即可，用逗号分隔

a = [1, 2, 'hello!']
# 或者可以用下面的方法快速定义
b = [i for i in range(10)]

对于列表a，我们有可以对其进行遍历，也可以访问列表的下标

a = [1, 2, 'hello!']
#遍历列表
for i in a:
	print(i)
#访问下标
for i in range(len(a)):
	print(a[i])

这里给出list的操作。希望大家不要尝试全部背诵，可以把这篇博客当作百科书，随用随查

len(a)  # 返回列表元素个数
a.append('dove')  # append用于单个元素的加入,在最后添加
a.insert(0,'hello')  # insert的两个参数：要插入的顺序，要插入的内容

a.extend(['i','love','dove']) # extend用于整个列表的加入
a.index(123)  #从第一个元素遍历，输出第一次出现123这个元素的位置
a.index(123,1,3)  #从第一个到第三个元素中，第一次出现123这个元素的位置
a.count(123)  # 序列中出现123的次数

a.sort()  # 排序 从小到大
a.reverse() # 逆序输出
a.clear()  # 清空列表
del a[2]  # 指定删除a下标为2的元素

练习
输出商品列表，用户输入序号，显示用户选中的商品。
商品 li = [“手机”, “电脑”, “鼠标垫”, “游艇” ]
a. 允许用户添加商品
b. 用户输入序号显示内容

li = ["手机", "电脑", "鼠标垫", "游艇" ]
mer = input("请输入您想加入的商品:")
li.append(mer)
print("商品现有",li)
wan = int(input("请输入序号："))
print(li[wan])

3.3 元组

元组就是不能够修改的list，一般很少使用，下面给出方法

#将一些值用逗号分隔
a=1,2,3
print(a)

#常用做法 小括号
a=(1,2,3)

#调用函数tuple:它将一个序列作为参数，并将其转换为元组
a=tuple([1,2,3])
b=tuple("abc")
print(a,b,sep='\n')

#特殊情况：表示只包含一个值的元组
a=42,
b=(42,)
print(a,b,sep='\n')

3.4 字典

字典类型是很特殊的一种类型。它的元素是一对数据，也可以叫一组关系 用大括号{}
每一个元素表示为 <键>:<值>元素之间用逗号隔开。
我们在知道键的情况下，可以通过索引找到对应的值

zidian = {'outside':'green','inside':'blue'}
print(zidian['outside'])

同样，在C/C++中对数组的操作，在python中对list的操作同样可以类比，只不过在表达上有些许区别而已。以下给出字典的操作

#字典类型操作函数和方法
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('0.最初定义的字典变量',dic)
del  dic[1]
print('1.删除第一项',dic)
print('2.判断键“1”是否在字典中(已在上一步删除)',1 in dic)

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('3.返回所有键的信息',dic.keys())
print('4.返回所有值的信息',dic.values())
print('5.返回所有键值对的信息',dic.items())

dic = dict(((1,'mcx'),(2,'zyc'),(3,'ch'),(4,'ylx'),(5,'ljw'),(6,'wb'),(7,'dsp')))   
print('5+.利用dict创建一个字典',dic)
print('6.若存在该键,则返回对应的值，否则返回<default>',dic.get(6,'wb'))
print('7.若存在该键,则去除并返回对应的值，否则返回<default>',dic.pop(6,'wb'))
print('8.随机取出一个键值对并以元组形式返回',dic.popitem())

print('9.删除所有键值对',dic.clear())
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('10.返回字典元素个数',len(dic))

字典类型在进行对应数据处理时非常重要，但对于前期学习的同学们，能够熟练掌握list就已经足够，因为list就是C/C++数组的超级加强版
练习
将这三个字典都存储在一个名为 people 的列表中。
a={‘name’:‘laosun’,‘phone’:13032435356,‘sex’:1}
b={‘name’:‘laozheng’,‘phone’:13038659870,‘sex’:1}
c={‘name’:‘laosong’,‘phone’:13032867908,‘sex’:2}
遍历这个列表，将其中每个人的所有，信息都打印出来。
输出第一个人的名字，第二个人的电话号码，第三个人的性别

people=[]
a={'name':'laosun','phone':13032435356,'sex':1}
b={'name':'laozheng','phone':13038659870,'sex':1}
c={'name':'laosong','phone':13032867908,'sex':2}
people.append(a)
people.append(b)
people.append(c)
print(people)
for k in people:
    print(k)
people[0]['name']    
people[1]['phone']
people[2]['sex']

python语法 - 字符串

考虑到字符串的重要地位，以及python中字符串的特殊形式，我们字符串单独拿出来讲。

4.1 字符串的定义

字符串的定义我们在最上面就已经解释过，直接利用单引号/双引号/三连单引号，双引号括起来，就已经做好了一个字符串。python的字符串非常“宽松”，即，基于python的保护机制，在使用字符串时完全不用考虑越界，超范围等等C语言中很麻烦的问题

a = 'I love esta'
b = ' I love'
print(a + b) # 如果想进行字符串连接的操作，直接 + 就可以

4.2 字符串的各种操作

在C语言中，字符串其实是利用数组去模拟的一种便捷数组表达。而python中，字符串更像一个变量。因此对字符串的操作十分自由。

a = 'I love esta'
b = 'I love'
print(a + b) # 上文已经讲过，加法代表两个字符串连接
c = '人类的本质是复读机'
print(c*5) # 直接乘法代表字符串重复多少次
d = '人类'
print(d in c) # 利用in判断d是否是后者的子串

a.upper()  # 将字符串的所有字母改为大写
a.lower()  # 将字符串的所有字母改为小写 
a.split(' ') # 将字符串根据括号内的内容-分隔开，返回保存在列表中
a.count('e')
a.replace('esta','Esta')

除了字符串整体的操作，python还支持字符串的切片。

a = 'I love esta'
print(a[0])  # 返回第一个字符
print(a[-1]) # 返回最后一个字符
print(a[3:6])# 获取字符串切片，左闭右开
print(a[1:9:2])  #指从第一位开始，到第九位之前，每隔两个取一个
print(a[::-1])  #字符串的逆序

fstring="esta"
print(fstring.center(20,"="))  #将目标字符串放在宽度为20的居中位，其余用=填充
print("|".join(estring))  #将目标字符串夹在join括号内字符串的出最后一位的字符后边

python语法 - 函数

python的函数定义同样十分简单。python定义函数时，不需要考虑参量的类型，返回值类型等等问题。直接使用def就可以定义函数；同样，函数必须缩进。

def hello():     #参数括号中可以写入你的参数
    print('hello!')
        
def hello2(a):   #这里我们想要调入一个列表，但我们不用事先说明他是个列表
    print(a)
    
hello2([1,2,3]) # 当然也是没有任何问题的
hello2("hi,I'm a string!") #字符串也没有问题
#返回参数的函数
def add(a,b):
	return a+b
add(4,4)
# 虽然python很好用，但是要注意，你传入的内容应该符合函数的操作！

此外，python还接受这样的操作：

def hello(name,greeting='Hello',punctuation='!'):#提前定义变量的值
    print('{},{}{}'.format(greeting,name,punctuation))
hello('python','Hi','^_^')
hello('python',punctuation='^_^')
hello('python',greeting='Glad to see you')


#星号收集余下的位置参数并存放在一个元组中
def print_params1(title,*params):
    print(title,end=' ')
    print(params)
print_params1('Params:',1,2,3)   

#收集关键字参数需要**,得到的为一个字典
def print_params2(**params):
    print(params)
print_params2(x=1,y=2,z=3)
#1、拆分序列*
def add(x,y):
    return x+y
params=1,2
print(add(*params))

def mutiply(x,y,z):
    return x+y*z
params1=[2,3]
print(mutiply(1,*params1))   #星号部分必须位于参数列表末尾

#2、拆分字典**
def hello(greeting="Hello",name='World'):
    print(greeting+',',name)
dic={'name':'MMS','greeting':'Glad to see you'}
hello(**dic)

参考文献：Magnus Lie Hetland. Python基础教程（第3版）. 人民邮电出版社