# python --version
Python 2.7.5

# vim 1.py						

#!/usr/bin/python				# 声明类型,指明解释器命令路径
#-*- coding: utf-8 -*-			# 指定字符格式为utf-8（可以打印中文）,python3不用再指定了

print "hellow world"			# python2的写法,python3执行会报错
print("hello world")			# python3的写法,python2也可以执行
print("哈哈")				   	   # python2指定了utf-8字符，那么这里就可以使用中文

执行方法一:
# python 1.py

执行方法二:
# chmod 755 1.py
# ./1.py						# 需要有执行权限和声明类型才能这样执行

# python

>>> print ("hello world")
hello world
>>> exit()					--使用exit()或quit()或ctrl+d键来退出

cenots7系统如果gnome图形界面和开发工具都安装了,那么就还需要安装zlib-devel,openssl,openssl-devel这几个依赖包
# yum install zlib-devel openssl openssl-devel

# tar xf Python-3.6.6.tar.xz -C /usr/src/
# cd /usr/src/Python-3.6.6/

# ./configure  --enable-optimizations
关于--enable-optimizations参数的说明:可能因不同的同学电脑的兼容问题，有些同学会在make步骤卡住，可以尝试去掉此参数重新编译
# make					
这一步时间较长(20-30分钟，视机器速度而定)
# make install
编译第三步几乎不会报错，除非你的安装路径空间不够了

# ls /usr/local/bin/python3.6
确认此命令,此为python的主命令(也就是解释器)，并且要与默认的python2区分开
# ls /usr/local/bin/pip3.6			
确认此命令,pip为python安装模块的命令,后面课程会用得到

# yum install epel-release -y
# yum install python36

# tar xf pycharm-professional-2018.2.4.tar.gz -C /usr/local/
# sh /usr/local/pycharm-2018.2.4/bin/pycharm.sh &

1,使用git clone下载安装到家目录的.pyenv目录
# git clone https://github.com/pyenv/pyenv.git ~/.pyenv

2,设置环境变量,并使之生效,这样才能直接使用pyenv命令
# echo 'export PYENV_ROOT="$HOME/.pyenv"' >> /etc/profile
# echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> /etc/profile
# source ~/.bash_profile

# pyenv help
# pyenv install -l		--或者使用pyenv install --list列出所有的python当前可用版本

3,先解决常见依赖包的问题，否则下一步安装会报错
# yum install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel libpcap-devel xz-devel -y

4,安装3.6.6版本,需要下载并安装,速度较慢。它会安装到~/.pyenv/versions/下对应的版本号
# pyenv install 3.6.6

5,查看当前安装的版本,前面带*号的是默认使用的版本
# pyenv versions		
* system (set by /root/.pyenv/version)
  3.6.6

1，将pyenv-virtualenv这个plugin下载安装到pyenv根目录的plugins/下叫pyenv-virtualenv
# git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv

2，把安装的3.6.6版本做一个隔离的虚拟化环境，取名为python3.6.6(这个取名是自定义的)
# pyenv virtualenv 3.6.6  python3.6.6

3，active激活使用，但报错
# pyenv activate python3.6.6		
Failed to activate virtualenv.

Perhaps pyenv-virtualenv has not been loaded into your shell properly.
Please restart current shell and try again.
解决方法:
# echo 'eval "$(pyenv init -)"' >> /etc/profile
# echo 'eval "$(pyenv virtualenv-init -)"' >> /etc/profile
# source /etc/profile

4,再次激活，成功
# pyenv activate python3.6.6
pyenv-virtualenv: prompt changing will be removed from future release. configure `export PYENV_VIRTUALENV_DISABLE_PROMPT=1' to simulate the behavior.
(python3.6.6) [root@daniel ~]# pip install ipython		--安装一个ipython测试

5,使用ipython测试完后退出虚拟环境
(python3.6.6) [root@daniel ~]# ipython
In [1]: print ("hello word")                                                    
hello word

In [2]: exit          		                                                          
(python3.6.6) [root@daniel ~]# pyenv deactivate	 --这里exit就退出终端了，用此命令退出虚拟环境
[root@daniel ~]# 

这样的话，你可以在linux安装多个版本的python,使用不同的隔离环境来开发不同版本的python程序.

删除隔离环境的方法:
# pyenv uninstall python3.6.6

help(print)			# 帮助方法

print("hello world") 			
print("python")		# 这是两句分开的打印，会打印两行

print("hello world\npython")	# 打印的结果会换行

print('''hello world
       python''')  	# 打印的结果会换行
      
print("hello world
       python")   	# 错误写法

print('hello world', end="") 	# python3里加上end=" "，可以实现不换行打印.类似shell里的echo -n
print("python")

print("hello world \
python")			  # 使用\符号连接行，物理上换了行，逻辑上并没有换行。不建议用\符号来连接行

print("hello world" 
      "python")   # (),[],{}里的多行内容不用\连接，但需要每行引起来;打印出来的结果不换行

print("\033[31;1;31m hello world\033[0m")
print("\033[31;1;32m hello world\033[0m")
print("\033[31;1;33m hello world\033[0m")
print("\033[31;1;34m hello world\033[0m")
print("\033[31;1;35m hello world\033[0m")
print("\033[31;1;36m hello world\033[0m")
结果如下:

print(Hello, World!

# SyntaxError: invalid syntax

File "main.py", line 1
    print(Hello, World!
                      ^
SyntaxError: invalid syntax

print(greetings)

# NameError: name 'greetings' is not defined

greetings = 'Howdy 🤠'
print(greetings)

# Output: Howdy 🤠

message = 'The air quality is '
print(message + 28)

# TypeError: can only concatenate str (not "int") to str

28TypeErrorstr()
message = 'The air quality is '
print(message + str(28))

# Output: The air quality is 28

import keyword			# 导入keyword模块
print(keyword.kwlist)  	# 打印上面的关键字列表

num = 100     			# num第一次出现是表示创建(定义)这个变量    
num = num-10		
print(num)

name1 = "daniel"
print(id(name1))
name2 = "daniel"
print(id(name2))   # id()函数用于获取对象内存地址编号;name1和name2得到的id相同,说明指向同一个内存空间

a = 1
print(id(a))
b = 2
a = 3
print(id(a))
c = 1
print(id(c))

1413311520
1413311584
1413311520
第1次打印和第2次打印的id结果不一样,说明a=3是重新开辟了一个内存空间存放3这个值
第1次打印和第3次打印的id结果一样,说明c=1相当于是把存放1这个值的内存空间名由a换成了c

a = 1
b = 2
c = 1

print(id(a))
print(id(b))
print(id(c))
结果: id(a)与id(c)得到的结果一样，因为它们的值一样。

a = 1
b = 2
c = 1
a = 2

print(id(a))
print(id(b))
print(id(c))
结果: id(a)与id(b)得到的结果一样，因为它们的值一样。

a, b = 1, 2				# 可以像这样一次定义多个变量
print(a, b)

a, b = b, a
print(a, b)

name = "zhangsan"		# str类型
age = 25				# 25没有加引号，则为int类型；加了引号，则为str类型;
height = 1.8			# float类型
marry = True			# bool类型

print(type(name))			# 通过type()内置函数得知变量的类型
print(type(age))
print(type(height))
print(type(marry))

age = 25					
print(type(age))	# int类型
age = str(25)
print(type(age))	# str类型

name = "zhangsan"
age = 25				

print(name, "你" + age + "岁了")    # str+int，字符串拼接报错;age=str(25),这一句就可以成功。

name = input("what is your name: ")
age = input("what is your age: ")		# input输入的直接就为str类型，不需要再str()转换了

print(name, "你" + age + "岁了")

print("="*10)				 # 表示连续打印10个=符号
print("1-系统")
print("2-数据库")
print("3-quit")
print("="*10)
或者
print("="*10)
print('''1-系统				# 使用'''  '''符号来换行
2-数据库
3-quit''')
print("="*10)
结果一样，如下:

name = "daniel"
age = str(20)

# 字符串拼接的写法
print(name+",你有"+age+"岁了")

# 两种格式化输出的写法
print("%s,你有%s岁了" % (name, age))
print("{},你有{}岁了".format(name, age))

name = "zhangsan"		# str类型
age = 25				# 25没有加引号，则为int类型；加了引号，则为str类型;
height = 1.8			# float类型
marry = True			# bool类型

print(type(name))			# 通过type()内置函数得知变量的类型
print(type(age))
print(type(height))
print(type(marry))

age = 25					
print(type(age))	# int类型
age = str(25)
print(type(age))	# str类型

name = "zhangsan"
age = 25				

print(name, "你" + age + "岁了")    # str+int，字符串拼接报错;age=str(25),这一句就可以成功。

name = input("what is your name: ")
age = input("what is your age: ")		# input输入的直接就为str类型，不需要再str()转换了

print(name, "你" + age + "岁了")

name = input("请输入你的名字:")
age = int(input("请输入你的年龄:"))

print(name+",你5年后为"+str(age+5)+"岁了")

print("="*10)				 # 表示连续打印10个=符号
print("1-系统")
print("2-数据库")
print("3-quit")
print("="*10)
或者
print("="*10)
print('''1-系统				# 使用'''  '''符号来换行
2-数据库
3-quit''')
print("="*10)
结果一样，如下:

name = "daniel"
age = str(20)

# 字符串拼接的写法
print(name+",你有"+age+"岁了")

# 两种格式化输出的写法
print("%s,你有%s岁了" % (name, age))
print("{},你有{}岁了".format(name, age))

name = input("请输入你的名字:")
age = int(input("请输入你的年龄:"))

print(name+",你5年后为"+str(age+5)+"岁了")
print("%s,你5年后为%d岁了" % (name, age+5))
print("{},你5年后为{}岁了".format(name, age+5))

name = input("输入你的名字:")
sex = input("输入你的性别:")
job = input("输入你的职业:")
num = input("输入你的手机号:")

print("-"*10+"information of "+name+"-"*10)
print("name: {}".format(name))
print("sex: {}".format(sex))
print("job: {}".format(job))
print("phonenum: {}".format(num))

name = input("输入你的名字:")
sex = input("输入你的性别:")
job = input("输入你的职业:")
num = input("输入你的手机号:")

print("-"*10+"information of "+name+"-"*10)
print('''name: {}
sex: {}
job: {}
phonenum: {}
'''.format(name, sex, job, num))

name = input("输入你的名字:")
sex = input("输入你的性别:")
job = input("输入你的职业:")
num = input("输入你的手机号:")

print("-"*10+"information of "+name+"-"*10)

print("name: {}\nsex: {}\njob: {}\nphonenum: {}".format(name, sex, job, num))

print(type(2<=1)) 		# 结果为bool类型，所以返回值要么为True,要么为False.

在SQL语句里也有in和not in运算符;如(没有学习mysql的话，后面会学习了就知道了)
mysql > select * from xxx where name in ('tom','john');

a = [1,2,3]			# 后面会学到，这是列表
b = a[:]			# 后面会学到，这是列表的切片
c = a
print(b is a)		# False
print(b == a)		# True

print(c is a)		# True
print(c == a)		# True

result = 3-4 >= 0 and 4 * (6 - 2) > 15
print(result)

result = -1 >= 0 and 16 > 15     # 算术运算后
result = False and True			 # 比较运算后
result = False  				 # 逻辑运算后

if 条件;then
	执行动作一
fi

if 条件;then
	执行动作一
else
	执行动作二
fi

if 条件一;then
	执行动作一
elif 条件二;then
	执行动作二
elif 条件三;then
	执行动作三
else
	执行动作四
fi

case "变量" in 
	值1 )
		  执行动作一
		  ;;
	值2 )
		 执行动作二
		  ;;
	值3 )
		 执行动作三
		  ;;
	* )
		 执行动作四
esac

if 条件:					# 条件结束要加:号(不是;号)
	执行动作一			  # 这里一定要缩进（tab键或四个空格)，否则报错
    					 # 没有fi结束符了，就是看缩进

if 条件:
	执行动作一			
else:					# else后面也要加:
	执行动作二

if 条件一:
	执行动作一
elif 条件二:			  # elif 条件后面都要记得加:
	执行动作二
elif 条件三:
	执行动作三
else:
	执行动作四

# 单分支判断
if True:
    print("真")				# 前面一定要缩进(tab键或4个空格)

# 双分支判断
if True:
    print("真")				# 前面一定要缩进(tab键或4个空格)
else:
    print("假")				# 前面一定要缩进(tab键或4个空格)

# 多分支判断
num = 34
gnum = int(input("你猜:"))
if gnum > num:
    print("大了")				# 前面一定要缩进(tab键或4个空格)
elif gnum < num:
    print("小了")				# 前面一定要缩进(tab键或4个空格)
else:
    print("对了")				# 前面一定要缩进(tab键或4个空格)

if 1 > 0:
    print("yes")
else:
    print("no")
print("haha")
    print("hehe")

name = input("输入你的名字:")
sex = input("输入你的性别:")
age = int(input("输入你的年龄:"))

if sex == "男" and age >= 18:
    print("{},sir".format(name))
elif sex == "男" and age <18:
    print("{},boy".format(name))
elif sex == "女" and age >= 18:
    print("{},lady".format(name))
elif sex == "女" and age < 18:
    print("{},girl".format(name))
else:
    print("错误")

year = int(input("输入一个年份:"))

if year % 4 == 0 and year % 100 != 0:
    print("{}是闰年".format(year))
elif year % 400 == 0:
    print("{}是闰年".format(year))
else:
    print("{}是平年".format(year))

if 条件一:
    if 条件二:
		执行动作一		# 条件一，二都为True，则执行动作一
    else:
        执行动作二		# 条件一True，条件二False，则执行动作二
    执行动作三			# 条件一True，条件二无所谓，则执行动作三
else:
    if 条件三:
        执行动作四		# 条件一False，条件三True，则执行动作四
    else:
        执行动作五		# 条件一False,条件三False,则执行动作五
	执行动作六			# 条件一False,条件二，三无所谓，则执行动作六
执行动作七				# 与if里的条件无关，执行动作七

name = input("输入你的名字:")
sex = input("输入你的性别:")
age = int(input("输入你的年龄:"))

if sex == "男":
    if age >= 18:
        print("{},sir".format(name))
    else:
        print("{},boy".format(name))
elif sex == "女":
    if age >= 18:
        print("{},lady".format(name))
    else:
        print("{},girl".format(name))
else:
    print("性别有误")

year = int(input("输入一个年份:"))

if year % 4 == 0:
    if year % 100 != 0:
#    and year % 100 != 0:
        print("{}是闰年".format(year))
    if year % 400 == 0:
        print("{}是闰年".format(year))
else:
    print("{}是平年".format(year))

新手村村长:print("啊，今天天气真好啊")
新手村村长:print("啊，今天天气真好啊")
新手村村长:print("啊，今天天气真好啊")
......
新手村村长:print("看在你陪我说话100次的份上，小伙子不错，给你一把屠龙刀吧!")

while 条件:
      条件满足时候:执行动作一
	  条件满足时候:执行动作二
      ......

i = 1
while i < 11:
   print(i, end=" ")
   i += 1

i = 1
while i < 101:
    if i % 2 == 1:
        print(i, end=" ")
    i += 1

continue		跳出本次循环，直接执行下一次循环    
break			退出循环，执行循环外的代码　
exit()			退出python程序，可以指定返回值

import random				# 导入随机数模块(后面会专门讲模块的使用，这里先拿来用用)

num = random.randint(1, 100)	# 取1-100的随机数（包括1和100)

while True:
    gnum = int(input("你猜:"))
    if gnum > num:
        print("猜大了")
    elif gnum < num:
        print("猜小了")
    else:
        print("猜对了")
        break
        
print("领奖")

i = 2
sum = 0

# 方法一
while i <= 100:
    sum += i
    i += 2
print(sum)

# 方法二
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print(sum)

# 方法三(了解)
while i <= 100:
    if i % 2 == 1:
        i += 1
        continue
    else:
        sum += i
        i += 1
print(sum)

for 变量  in  数据:
    重复执行的代码

for i in 1, 2, 3, 4, 5:
    print(i, end=" ")
print()

for i in range(1, 6):	# range()函数，这里是表示1，2，3，4，5（不包括6）
    print(i)
    
for i in range(6):		# range()函数，这里是表示0，1，2，3，4，5（不包括6，默认从0开始）
    print(i)    

for i in range(1, 100, 2):
    print(i, end=" ")
print()

for i in range(100, 1, -2):
    print(i, end=" ")

sum = 0
for i in range(1, 101):
    if i % 5 == 0 and i % 2 == 1:
        sum += i
print(sum)

for i in range(1, 10):
    for j in range(1, i+1):
        print("{}*{}={}".format(j, i, i*j), end=" ")
    print()

num = int(input("输入一个大于2的整数"))

for i in range(2, num):
    if num % i == 0:
        print("不是质数")
        break
else:						# 这里的else是与for在同一列上,不与if在同一列。
   	 print("是质数")

name = input("输入你的名字:")
age = int(input("输入你的年龄:"))

#print(name, "你", age, "岁了")
print(name+",你5年后"+str(age+5)+"岁了")
print("%s,你5年后%d岁了" % (name, age+5))
print("{},你5年后{}岁了".format(name, age+5))

新手村村长:print("啊，今天天气真好啊")
新手村村长:print("啊，今天天气真好啊")
新手村村长:print("啊，今天天气真好啊")
......
新手村村长:print("看在你陪我说话100次的份上，小伙子不错，给你一把屠龙刀吧!")

while 条件:
      条件满足时候:执行动作一
	  条件满足时候:执行动作二
      ......

i = 1
while i < 11:
   print(i, end=" ")
   i += 1

i = 1
while i < 101:
    if i % 2 == 1:
        print(i, end=" ")
    i += 1

continue		跳出本次循环，直接执行下一次循环    
break			退出循环，执行循环外的代码　
exit()			退出python程序，可以指定返回值

import random				# 导入随机数模块(后面会专门讲模块的使用，这里先拿来用用)

num = random.randint(1, 100)	# 取1-100的随机数（包括1和100)

while True:
    gnum = int(input("你猜:"))
    if gnum > num:
        print("猜大了")
    elif gnum < num:
        print("猜小了")
    else:
        print("猜对了")
        break
        
print("领奖")

i = 2
sum = 0

# 方法一
while i <= 100:
    sum += i
    i += 2
print(sum)

# 方法二
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print(sum)

# 方法三(了解)
while i <= 100:
    if i % 2 == 1:
        i += 1
        continue
    else:
        sum += i
        i += 1
print(sum)

for 变量  in  数据:
    重复执行的代码

for i in 1, 2, 3, 4, 5:
    print(i, end=" ")
print()

for i in range(1, 6):	# range()函数，这里是表示1，2，3，4，5（不包括6）
    print(i)
    
for i in range(6):		# range()函数，这里是表示0，1，2，3，4，5（不包括6，默认从0开始）
    print(i)    

for i in range(1, 100, 2):	# 循环1-100的奇数
    print(i, end=" ")
print()

for i in range(100, 1, -2):
    print(i, end=" ")

sum = 0
for i in range(1, 101):
    if i % 5 == 0 and i % 2 == 1:
        sum += i
print(sum)

1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

* 
* * 
* * * 
* * * * 
* * * * * 
* * * * * * 
* * * * * * * 
* * * * * * * * 
* * * * * * * * * 

* 
* * 
* * * 

for line in range(1, 4):
    for field in range(1, 4):
        print("*", end=" ")
    print()
    
* * * 
* * * 
* * * 

for line in range(1, 4):
    for field in range(1, line+1):
        print("*", end=" ")
    print()
    
* 
* * 
* * * 

for line in range(1, 10):
    for field in range(1, line+1):
        print("*", end=" ")
    print()
* 
* * 
* * * 
* * * * 
* * * * * 
* * * * * * 
* * * * * * * 
* * * * * * * * 
* * * * * * * * * 

for line in range(1, 10):
    for field in range(1, line+1):
        print("{}*{}={}".format(field, line, field*line), end="\t")
    print()

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	

num = int(input("输入一个大于2的整数"))

for i in range(2, num):
    if num % i == 0:
        print("不是质数")
        break
else:						# 这里的else是与for在同一列上,不与if在同一列。
   	 print("是质数")

string1 = "hello"
string2 = 'hello'
string3 = """hello
python"""
string4 = '''hello
world'''
string5 = input("input anything: ")
string6 = str(18)

print(isinstance(string3,str))	# isinstance函数可以用来判断数据是否为某一个数据类型，返回值为True或False

name = "daniel"

str1 = "===" + name + "==="
str2 = "===%s===" % (name)
str3 = "==={}===".format(name)

print(str1)
print(str2)
print(str3)				# 三种方法结果一样

name = "张三"

print("你好,", name)		# 这种打印的结果与后三种稍有不同
print("你好," + name)
print("你好,%s" % (name))
print("你好,{}".format(name))

str1 = "hello,python"

for i in str1:					# 直接用for循环遍历字符串
    print(i, end=" ")

str1 = "hello,python"

for i, j in enumerate(str1):	# 枚举
    print(i, j)

str1 = "hello,python"

# 方法一
for i, j in enumerate(str1):	
    print(i+1, j)
# 方法二
num = 1
for i in str1:
    print(num, i)
    num += 1

shell里的方法:
# echo abcdefg  | cut -c3-5
cde

# echo abcdefg  | awk '{print substr($0,3,3)}'		# substr()是awk里的截取函数
cde

# echo abcdefg  | sed -r 's/(..)(...)(.*)/\2/'		# sed的分域操作
cde

python里循环的方法(但不建议):
str1 = "abcdefg"

for index, i in enumerate(str1):
    if 5 > index > 1:
        print(i, end="")

a = "abcdefg"
print(a[0:3])		# 取第1个到第3个字符（注意，不包含第4个）
print(a[2:5])		# 取第3个到第5个字符（注意，不包含第6个）

print(a[0:-1])		# 取第1个到倒数第2个（注意:不包含最后一个)
print(a[1:])		# 取第2个到最后一个
print(a[:])			# 全取
print(a[0:5:2])		# 取第1个到第5个，但步长为2（结果为ace)
print(a[::-1])		# 字符串的倒序（类似shell里的rev命令)

str1 = "abcdefghijk"

print(str1[2:0:-1])
print(str1[:3:-1])

abc = "hello,nice to meet you"

print(len(abc))					# 调用len()函数来算长度						      (常用)
print(abc.__len__())			# 使用字符串的__len__()方法来算字符串的长度

print(abc.capitalize())			# 整个字符串的首字母大写
print(abc.title())			    # 每个单词的首字母大写
print(abc.upper())			    # 全大写
print(abc.lower())			    # 全小写
print("HAHAhehe".swapcase())	# 字符串里大小写互换

print(abc.center(50,"*"))		# 一共50个字符,字符串放中间，不够的两边补*
print(abc.ljust(50,"*"))		# 一共50个字符,字符串放左边，不够的右边补*	       （常用)
print(abc.rjust(50,"*"))		# 一共50个字符,字符串放右边，不够的左边补*

print(" haha\n".strip())		# 删除字符串左边和右边的空格或换行	(常用,处理文件的换行符很有用)
print(" haha\n".lstrip())		# 删除字符串左边的空格或换行
print(" haha\n".rstrip())		# 删除字符串右边的空格或换行

print(abc.endswith("you"))		# 判断字符串是否以you结尾	    类似于正则里的$		(常用)
print(abc.startswith("hello"))	# 判断字符串是否以hello开始	类似于正则里的^		(常用)

print(abc.count("e"))			# 统计字符串里e出现了多少次						   (常用)

print(abc.find("nice"))		# 找出nice在字符串的第1个下标，找不到会返回-1
print(abc.rfind("e"))		# 找出最后一个e字符在字符串的下标，找不到会返回-1
print(abc.index("nice"))	# 与find类似，区别是找不到会有异常（报错）
print(abc.rindex("e"))		# 与rfind类似，区别是找不到会有异常（报错）

print(abc.isalnum())		# 判断是否为数字字母混合(可以有大写字母，小写字母，数字任意混合)
print(abc.isalpha())		# 判断是否全为字母(分为纯大写，纯小写，大小写混合三种情况)
print(abc.isdigit())		# 判断是否为纯数字
print(abc.islower())		# 判断是否为纯小写字母
print(abc.isspace())		# 判断是否为全空格

print(abc.upper().isupper())	# 先把abc字符串全转为大写，再判断是否为全大写字母，结果为True

char = input("输入: ")

if char.isdigit():
    print("输入的是数字")
elif char.isalpha():
    if char.isupper():
        print("输入的是纯大写字母")
    elif char.islower():
        print("输入的是纯小写字母")
    else:
        print("输入是大小写混合字母")
else:
    print("输入的是其它")

aaa = "hello world,itcast"
bbb = aaa.replace('l','L',2)	# 从左到右，把小写l替换成大写L，并且最多只替换2个
print(aaa)			# 原值不变
print(bbb)			# 改变的值赋值给了bbb变量，所以这里看到的是替换后的值

print("root:x:0:0".split(":"))			# 以:为分隔号,分隔成列表
print("root:x\n:0:0".splitlines())		# 以\n为分隔号，分隔成列表

print(" ".join(['df', '-h']))	# 把列表里的元素以前面引号里的分隔符合成字符串

os_list = ["rhel", "centos", "suse", "ubuntu"]

print(os_list)

os_list = ["rhel", "centos", "suse", "ubuntu"]

for i, j in enumerate(os_list):
    print(i, j)

os_list = ["rhel", "centos", "suse", "ubuntu"]

print(os_list[1:3])
print(os_list[1:-1])		
print(os_list[::2])			# 打印第1个和第3个元素
print(os_list[::-1])		# 通过切片来倒序

os_list = ["rhel", "centos", "suse", "ubuntu"]

print(id(os_list))
os_list.reverse()		# 通过reverse操作来倒序，并且是直接改变原数据
print(os_list)			# 列表的元素倒序了
print(id(os_list))		# 在倒序前后id()函数得到的值一样，说明内存地址不变，但值变了(可变数据类型)

os_list = ["rhel", "centos", "suse"]
# 增
os_list.append("ubuntu")			# 在列表最后增加一个元素
print(os_list)
os_list.insert(2, "windowsxp")	# 插入到列表，变为第三个
print(os_list)
# 改
os_list[2] = "windows10"			# 修改第三个
print(os_list)
# 删
os_list.remove("windows10") 		# 删除操作，还可以使用del os_list[2]和os_list.pop[2];它们的区别del os_list是删除整个列表，os_list.pop()是默认删除列表最后一个元素；如果都用下标的话，则一样
print(os_list)
# 查
print(os_list[0])				# 通过下标就可以

# 其它操作
print(os_list.count("centos"))	# 统计元素出现的次数
print(os_list.index("centos"))	# 找出centos在os列表里的位置
os_list.reverse()				# 反转列表
print(os_list)
os_list.sort()					# 排序列表，按ASCII编码来排序
print(os_list)
os_list.clear()					# 清除列表所有元素，成为空列表,不是删除列表
print(os_list)

list1 = ["haha", "hehe", "heihei"]
list2 = ["xixi", "hoho"]

list1.extend(list2)    		# list1 += list2也可以，类似字符串拼接
print(list1)

math = ["张三", "田七", "李四", "马六"]
english = ["李四", "王五", "田七", "陈八"]
art = ["陈八", "张三", "田七", "赵九"]
music = ["李四", "田七", "马六", "赵九"]

list1 = math + english + art + music			
print(list1.count("张三"))

name_list = ["zhangsan", "lisi", "wangwu", "maliu"]
salary = [18000, 16000, 20000, 15000]

for i in range(len(name_list)):
    print("{}的月收入为{}元".format(name_list[i].ljust(10," "),salary[i]))
    
for index, name in enumerate(name_list):
    print("{}的月薪为{}元".format(name,salary[index]))

问题:找出工资最高的人叫啥?
print(name_list[salary.index(max(salary))])

emp = [["zhangsan", 18000], ["lisi", 16000], ["wangwu", 20000], ["maliu", 15000]]


for i in range(len(emp)):
    print("{}的月收入为{}元".format(emp[i][0].ljust(10," "),emp[i][1]))
    
for index, i in enumerate(emp):
    print("%s的月薪为%d元" % (i[0],i[1]))    

问题:找出最高工资的人叫啥?
emp = [["zhangsan", 18000], ["lisi", 16000], ["wangwu", 20000], ["maliu", 15000]]

emp2 = []
for i in emp:
    emp2.append(i[1])

print(emp[emp2.index((max(emp2)))][0])

tuple1 = (1, 2, 3, 4, 5, 1, 7)

print(type(tuple1))

print(tuple1.index(3))		# 打印3这个元素在元组里的下标	
print(tuple1.count(1))		# 统计1这个元素在元组里共出现几次
print(tuple1[2:5])			# 切片

tuple1[5] = 6					# 修改元组会报错

emp2 = (["zhangsan", 18000], ["lisi", 16000], ["wangwu", 20000], ["maliu", 15000])

emp2[0].append("haha")	# 元组里面的列表可以修改

print(emp2)

import getpass					# 这是一个用于隐藏密码输入的模块
			
username = input("username:")
password = getpass.getpass("password:")

if username == "daniel" and password == "123":
    print("login success")		
else:
    print("login failed")

# /usr/local/bin/python3.6 /项目路径/xxx.py

提示:因为没有学python的正则，你可以使用这样来判断  if 字符 in "abcdefghijklmnopqrstuvwxyz":

答:

tvlist = [
    "戏说西游记:讲述了西游路上的三角恋.",[
        "孙悟空:悟空爱上了白骨精......",
        "唐三藏:唐僧只想取经......",
        "白骨精:她爱上了唐僧......",
        ],
    "穿越三国:王二狗打怪升级修仙史",[
        "王二狗:开局一把刀,一条狗......",
        "吕布:看我方天画鸡......",
        "貂蝉:油腻的师姐,充值998就送!",
        ],
    "金瓶梅:你懂的",[
        "西门大官人:你懂的......",
        "潘金莲:你懂的......",
        "武大郎:你懂的......",
        "武松:你懂的......",
        ],
    "大明湖畔:我编不下去了......",[
        "夏雨荷:xxxxxx",
        "乾隆:xxxxxx",
        "容么么:xxxxxx",
    ],
]

提示部分代码
import random							# 导入random模块(后面会具体讲模块)
    
tv_name_num = random.randrange(0,len(tvlist),2)   # len(tvlist)长度为8,这是0,2,4,6四个数的随机
tv_role_num = tv_name_num + 1
print("今日的通告: ")
print(tvlist[tv_name_num])
print("可接的角色有: ")

提示部分代码:

money=20000

goods_list=[
    ["iphoneX",8000],
    ["laptop",5000],
    ["book",30],
    ["earphone",100],
    ["share_girlfriend",2000],
]

cart_list=[]

# 空字典
d1 = {}

# 键值对，key: value
d2 = {"name":"张三", "age":20, "city":"北京"}
#或
dict1 = {
    'stu01': "zhangsan",
    'stu02': "lisi",
}
print(d2)

d3 = dict(name="李四", age=25)
print(d3)

# 从列表元组创建
d4 = dict([("a",1), ("b",2)])
print(d4)

d5 = {i:i*2 for i in range(3)}
print(d5)   # {0: 0, 1: 2, 2: 4}

d = {"a":10, "b":20, "c":30, "d":40}

# 删除单个键值对
del d["a"]
print(d)  # {'b': 20, 'c': 30, 'd': 40}

# 删除整个字典对象（变量直接消失）
del d
# print(d)  # 报错 NameError

d = {"a":10, "b":20, "c":30}
val = d.pop("b")
print(val)  # 20
print(d)    # {'a': 10, 'c': 30}

# 可以设置默认值，键不存在不会报错
res = d.pop("x", None)
print(res) # None

d = {"a":1, "b":2}
item = d.popitem()
print(item) # ('b', 2)
print(d)    # {'a': 1}

d = {"a":10, "b":20}
d.clear()
print(d) # {}

# 增
dict1["stu05"] = "tianqi"		# 类似修改,如果key值不存在,则就增加
print(dict1)

# 改
dict1["stu04"] = "马六"		   # 类似增加,如果key值存在,则就修改
print(dict1)
# 字典的增加与修改的写法是一样的，区别就在于key是否已经存在

# 查
print(dict1["stu01"])   	# 如果key值不存在,会返回keyerror错误
print(dict1.get("stu01"))  	# 这种取值方法如果key值不存在,会返回none,不会返回错误

# 删
dict1.pop("stu05")  		# 删除这条；也可以del dict1["stu05"]来删除
dict1.popitem()  			# 删除显示的最后一条
dict1.clear()  				# 清空字典
print(dict1)

print(dict1.keys())   		# 打印所有的键：keys
print(dict1.values()) 		# 打印所有的值：values
print(dict1.items())  		# 把所有键值对一起拿出来，也就转成列表套元组了

# 上面这三种可以使用for来循环遍历

for key in dict1.keys():
    print(key)

for value in dict1.values():
    print(value)

for line in dict1.items():
    print(line)

dict1 = {
    '张三': 2,
    '田七': 4,
    '李四': 3,
    '马六': 2,
    '王五': 1,
    '陈八': 2,
    '赵九': 2,
}

答:
for i in dict1.items():
    if i[1] == 2:
        print(i[0])

city = {
    "北京": {
        "东城": "景点",
        "朝阳": "娱乐",
        "海淀": "大学",
    },
    "深圳": {
        "罗湖": "老城区",
        "南山": "IT男聚集",
        "福田": "华强北",
    },
    "上海": {
        "黄埔": "xxxx",
        "徐汇": "xxxx",
        "静安": "xxxx",
    },
}

print(city["北京"]["东城"])
city["北京"]["东城"]="故宫在这"
print(city["北京"]["东城"])
city["北京"]["昌平"]="我们在这"
print(city)
city["北京"]["海淀"]=["清华","北大","北邮"]
print(city["北京"]["海淀"])
city["北京"]["海淀"].append("北影")
print(city["北京"]["海淀"])

for index, i in enumerate(city["北京"].keys()):
    print(index+1, i)

for index, i in enumerate(city["北京"]["海淀"]):
    print(index+1, i)

set1 = {1, 2, 3, 4, 5, 1, 2}
set2 = {2, 3, 6, 8, 8}

print(type(set1))
print(set1)
print(set2)				# 打印的结果，没有重复值

set1 = {1, 4, 7, 5, 9, 6}
set2 = set([2, 4, 5, 9, 8])

# 交集
print(set1.intersection(set2))
print(set1 & set2)

print(set1.isdisjoint(set2))  			# 判断两个集合是否有交集,类型为bool(有交集为False,没交集为True)
# 并集
print(set1.union(set2))
print(set1 | set2)
# 差集(补集)
print(set1.difference(set2)) 			# set1里有,set2里没有
print(set1-set2)
print(set2.difference(set1)) 			# set2里有,set1里没有
print(set2-set1)
# 对称差集
print(set1.symmetric_difference(set2))  # 我有你没有的  加上 你有我没有的
print(set1^set2)
# 子集
set3=set([4, 5])
print(set3.issubset(set1))              # 判断set3是否为set1的子集
print(set1.issuperset(set3))            # 判断set1是否包含set3

# 集合的增加操作
set1.add(88)
print(set1)
set1.update([168, 998])                  # 添加多个
print(set1)

# 集合的删除操作
set1.remove(88)                         # 删除一个不存在的元素会报错
print(set1)
set1.discard(666)                       # 删除一个不存在的元素不会报错，存在则删除
print(set1)

math = ["张三", "田七", "李四", "马六"]
english = ["李四", "王五", "田七", "陈八"]
art = ["陈八", "张三", "田七", "赵九"]
music = ["李四", "田七", "马六", "赵九"]

print(set(math).intersection(set(english),set(music),set(art)))
# 或
print(set(math).intersection(set(english).intersection(set(music))).intersection(set(art)))

字符串，列表，元组     有下标，能切片，能拼接，for遍历

列表，集合，字典        可以增，删，改(集合有点特殊)

集合，字典里的key

字符串，列表，元组，字典, 集合

数字

f = open("文件路径","文件访问模式")		# 打开文件简单格式，需要赋值给一个变量


f.close()							   # 关闭的方法

with open("文件路径", '文件访问模式') as f:	# 此方法打开文件不用后面再使用close关闭了	

f = open('/tmp/1.txt", encoding="utf-8")		# 默认就是只读模式
# 如果不同平台,可能会字符集编码不一致,不一致的需要指定;一致的不用指定。

data1 = f.read()
data2 = f.read()				# 读第二遍

f.close()

print(data1)
print("="*50)
print(data2)	# 发现读第二遍没有结果;类似从上往下读了一遍，第二次读从最后开始了，所以就没结果了

f = open("/tmp/1.txt", "r")
print(f.tell())			# 结果为0 (告诉你光标在哪,刚打开文件，光标在0位置)
f.seek(5)				# 移你的光标到整个文件的第6个字符那(因为0为第一个)
print(f.tell())			# 结果为5
f.seek(2)				# 移你的光标到整个文件的第3个字符那，从0开始算，而不是从上面的位置开始算
print(f.tell())			# 结果为2

f.close()

f = open("/tmp/1.txt", mode="r")

data1 = f.read()		# 读了第一次后，光标在最后的位置
f.seek(0)				# 通过seek(0)将光标又重置回开始的位置
data2 = f.read()		# 再次读的话，就可以又重头读一遍了,data2变量的内容与data1的内容就一致了

f.close()

print(data1)
print("="*20)
print(data2)

f = open("/tmp/1.txt", "r")

f.seek(5)					# 光标移到第6个字符那里
data1 = f.read()			# read是读整个文件在光标后面的所有字符(包括光标所在的那个字符)，读完后，会把光标移到你读完的位置

f.seek(5)					# 光标重置到第6个字符那里
data2 = f.readline()		# readline是读光标所在这一行的在光标后面的所有字符(包括光标所在的那个字符)，读完后，会把光标移到你读完的位置

f.seek(5)					# 光标重置到第6个字符那里
data3 = f.readlines()		# readlines和read类似，但把读的字符按行来区分做成了列表

f.close()
print(data1)
print("="*30)
print(data2)
print("="*30)
print(data3)

f = open("/tmp/1.txt", mode="r")

data = f.readlines()			# 把文件从第1行到最后1行全读取，并转成列表

f.close()
print(data[2].strip())		# 通过列表的下标2取第3行，取出来的行是字符串，使用strip()去掉换行符

f = open("/tmp/1.txt", "r")

#循环方法一:
for index, line in enumerate(f.readlines()):
     print(index, line.strip())		# 需要strip处理，否则会有换行
        
# 循环方法二:这样效率较高，相当于是一行一行的读，而不是一次性全读（如果文件很大，那么一次性全读会速度很慢)
for index, line in enumerate(f):
     print(index, line.strip())

f.close()

f = open("/tmp/1.txt", mode="r")

for index, line in enumerate(f):		# 边读边循环
    if index == 2:						# 通过enumerate产生的下标来取第3行
        print(line.strip())				# 每一行的内容为字符串类型，使用strip()处理换行符

f.close()

f = open("/proc/meminfo", "r")

for line in f:
    if line.startswith("MemAvailable"):
        print(line.split()[1])

f.close()

f = open("/tmp/1.txt",'w')      # 只写模式(不能读),文件不存在则创建新文件，如果文件存在，则会复盖原内容(千W要小心)
data = f.read()  				# 只写模式,读会报错

f.close()

f = open("/tmp/2.txt", 'w')	# 文件不存在,会帮你创建(类似shell里的 > 符号)

f.write("hello\n")			# 不加\n,默认不换行写
f.write("world\n")
f.truncate()				# 截断，括号里没有数字，那么就是不删除
f.truncate(3)				# 截断，数字为3，就是保留前3个字节
f.truncate(0)				# 截断，数字为0，就是全删除
 
f.close()

f = open("/tmp/3.txt", "w")

for i in range(1, 10):
    for j in range(1, i+1):
        f.write("{}*{}={} ".format(i, j, i*j))
    f.write("\n")

f.close()

f = open("/tmp/2.txt", 'a')	# 类似shell里的>>符

f.write("hello\n")	
f.write("world\n")
f.truncate(0)				# 追加模式也可以使用truncate截取前面的数据

f.close()

r+文件必须要存在，相当于在只读模式的基础上加了写权限;

w+会清空原文件的数据，相当于在只写模式的基础上加了读权限；(可以在任意位置写，但要用seek定位光标，还要区分读光标和写光标)

a+不会改变原文件的数据，相当于在只追加模式的基础上加了读权限;（写是在最后写，即使用seek把光标移到前面，仍然会写在最后)

f = open("/tmp/2.txt", "w+")

f.write("11111\n")
f.write("22222\n")
f.write("33333\n")

print(f.tell())			# 打印结果为18,表示光标在文件最后

f.write("aaa")			# 这样写aaa,相当于在文件最后追加了aaa三个字符

f.seek(0)				# 表示把光标移到0(也就是第1个字符)
f.write("bbb")			# f.seek(0)之后再写bbb,就是把第一行前3个字符替换成了bbb

f.seek(0)				# 把光标再次移到0
f.readline()			# 把光标移到第1行最后
f.seek(f.tell())		# f.seek到第1行最后(如果这里理解为两个光标的话，你可以看作是把写光标同步到读光标的位置)
f.write("ccc")			# 这样写ccc，就会把第二行的前3个字符替换成ccc

f.close()

f = open("/tmp/4.txt", "w+")

for i in range(1, 10):
    for j in range(1, i+1):
        f.write("{}*{}={} ".format(i, j, i*j))
    f.write("\n")

f.seek(0)						# 这里需要seek(0),否则读不出来
data1 = f.read()

f.close()
print(data1)

f = open("/tmp/2.txt", "rb")

print(f.readline())
print(f.readline())

f.close()

f = open("/tmp/2.txt", "wb")
f.write("hello word".encode())	# 需要encode才能成功写进去

f.close()

import os
f1 = open("/tmp/1.txt", 'r')
f2 = open("/tmp/2.txt", 'w')

oldstr = input('old string:')
newstr = input('new string:')

for i in f1:
	if oldstr in i:
        i = i.replace(oldstr,newstr)
    f2.write(i)

os.remove("/tmp/1.txt")
os.rename("/tmp/2.txt","/tmp/1.txt")

f1.close()
f2.close()

info={
    "group1":{
        "class1":["李老师","班级平均成绩85"],
        "class2":["张老师","班级平均成绩89"],
    },
    "group2": {
        "class3": ["王老师", "班级平均成绩78"],
        "class4": ["赵老师", "班级平均成绩91"],
    },
    "group3": {
        "class5": ["马老师", "班级平均成绩82"],
        "class6": ["陈老师", "班级平均成绩79"],
    },
    "group4": {
        "class7": ["钱老师", "班级平均成绩90"],
        "class8": ["孙老师", "班级平均成绩80"],
    },
}

答案:

math = ["张三", "田七", "李四", "马六"]
english = ["李四", "王五", "田七", "陈八"]
art = ["陈八", "张三", "田七", "赵九"]
music = ["李四", "田七", "马六", "赵九"]

f = open("/tmp/1.txt", "r")

for index, line in enumerate(f):
    if index < 5:
        print(index+1, line.strip())
 
f.close()

f = open("/tmp/1.txt",'w')      # 只写模式(不能读),文件不存在则创建新文件，如果文件存在，则会复盖原内容(千W要小心)
data = f.read()  				# 只写模式,读会报错

f.close()

f = open("/tmp/2.txt", 'w')	# 文件不存在,会帮你创建(类似shell里的 > 符号)

f.write("hello\n")			# 不加\n,默认不换行写
f.write("world\n")
f.truncate()				# 截断，括号里没有数字，那么就是不删除
f.truncate(3)				# 截断，数字为3，就是保留前3个字节
f.truncate(0)				# 截断，数字为0，就是全删除
 
f.close()

f = open("/etc/yum.repos.d/local.repo", mode="w")

f.write("[local]\n")
f.write("name=local\n")
f.write("baseurl=file:///mnt\n")
f.write("enabled=1\n")
f.write("gpgcheck=0\n")

f.close()

f = open("/etc/yum.repos.d/local.repo", mode="w")

f.write('''[enable]
name=local
baseurl=file:///mnt
gpgcheck=0
enabled=1
''')

f.close()

f = open("/etc/yum.repos.d/local.repo", mode="w")

f.write("[enable]\n"
        "name=local\n"
        "baseurl=file:///mnt\n"
        "gpgcheck=0\n"
        "enabled=1\n")

f.close()

f = open("/etc/yum.repos.d/local.repo", mode="w")

f.write("[enable]\nname=local\nbaseurl=file:///mnt\ngpgcheck=0\nenabled=1\n")

f.close()

f = open("/tmp/3.txt", mode="w")

for i in range(1, 10):
    for j in range(1, i+1):
        f.write("{}*{}={}\t".format(j, i, i*j))
    f.write("\n")

f.close()

f = open("/tmp/2.txt", 'a')	# 类似shell里的>>符

f.write("hello\n")	
f.write("world\n")
f.truncate(0)				# 追加模式也可以使用truncate截取前面的数据

f.close()

r+文件必须要存在，相当于在只读模式的基础上加了写权限;

w+会清空原文件的数据，相当于在只写模式的基础上加了读权限；(可以在任意位置写，但要用seek定位光标，还要区分读光标和写光标)

a+不会改变原文件的数据，相当于在只追加模式的基础上加了读权限;（写是在最后写，即使用seek把光标移到前面，仍然会写在最后)

f = open("/tmp/2.txt", "w+")

f.write("11111\n")
f.write("22222\n")
f.write("33333\n")

print(f.tell())			# 打印结果为18,表示光标在文件最后

f.write("aaa")			# 这样写aaa,相当于在文件最后追加了aaa三个字符

f.seek(0)				# 表示把光标移到0(也就是第1个字符)
f.write("bbb")			# f.seek(0)之后再写bbb,就是把第一行前3个字符替换成了bbb

f.seek(0)				# 把光标再次移到0
f.readline()			# 把光标移到第1行最后
f.seek(f.tell())		# f.seek到第1行最后(如果这里理解为两个光标的话，你可以看作是把写光标同步到读光标的位置)
f.write("ccc")			# 这样写ccc，就会把第二行的前3个字符替换成ccc

f.close()

f = open("/tmp/4.txt", "w+")

for i in range(1, 10):
    for j in range(1, i+1):
        f.write("{}*{}={} ".format(i, j, i*j))
    f.write("\n")

f.seek(0)						# 这里需要seek(0),否则读不出来
data1 = f.read()

f.close()
print(data1)

f = open("/tmp/2.txt", "rb")

print(f.readline())
print(f.readline())

f.close()

f = open("/tmp/2.txt", "wb")
f.write("hello word".encode())	# 需要encode才能成功写进去

f.close()

# service sshd start
# /etc/init.d/sshd start
在centos6里，上面两条命令里的start都是最终调用/etc/init.d/sshd服务脚本里的start()函数

function start() {							# 定义函数名start，前面可以加function也可以不加
	/usr/sbin/sshd
}

stop() {
	kill -15 `cat /var/run/sshd/sshd.pid`
}

reload() {
	kill -1 `cat /var/run/sshd/sshd.pid`
}

restart() {
    stop
    start									# 函数里调函数就是函数的嵌套	
}

case "$1" in
	start )
		start								# 调用start函数
		;;
	stop )
		stop
		;;
	restart )
		restart
		;;
	reload )
		reload
		;;
	* )
		echo "参数错误"
esac

def funct1():				  # 函数名(),括号里可以写参数，也可以不写
    """函数说明或注释"""		 # 说明可以不写，大型程序为了程序可读性最好写
    print("进水")				# 函数代码主体
    print("洗衣服")		   # 函数代码主体
    print("脱水")				# 函数代码主体
    return 0				  # 函数返回值,可有可无


funct1()				 	# 调用函数的方式(调用函数也就是执行函数内部的代码)

def test(a, b, c):                		# 定义函数，传3个参数，分别为a,b,c
    print("进水{}升".format(a))			# 调用a的值
    print("洗{}".format(b))				 # 调用b的值	
    print("脱水{}分钟".format(c))          # 调用c的值

test(3, "毛衣", 10)                    # 将值3赋值给a变量,值"毛衣"赋值给b变量,值10赋值给c变量

def test(a, b):		# a,b是形参(形式上的参数,就是占位置用的)
    print(a + b)

    
test(1, 2)			# 1,2在这里是实参(实际的参数),实参也可以传变量,个数要与形参个数对应,也会按顺序来传参（位置参数);
# test(1)			# 执行的话会报错,位置参数要与形参一一对应,个数不能少
# test(1, 2, 3)		# 执行的话会报错,位置参数要与形参一一对应,个数也不能多
test(b=4, a=3)		# 这里是关键字调用,那么就与顺序无关了(关键字参数)

# test(5, b=6)		# 混用的话，就比较怪了，结果可以自行测试一下(结论:位置参数必须写在关键字参数的前面)

def connect_mysql(host, user, password, port=3306):	# port=3306为默认参数
    pass							# pass就类似一个占位符，保证函数完整，没有语法错误


host = input("input host:")
user = input("input user:")
password = input("password")

connect_mysql(host, user, password)			# 不用再传port的值的,默认就是3306;也可以传一个新的值替代3306

def ssh(ip, port=22):
    print("ssh {} -p {}".format(ip, port))

ssh("10.1.1.15", 2222)

def funct1(*args):		# 参数名前面加*(变量名可以自定义)就可以定义为可变长参数
    for i in args:
        print(i, end=" ")
    print()

    
funct1(1, 2, 3, 4, 5, 6, 7, 8)

定义一个函数，传多个整数，实现求和
def add_num(*args):
    sum = 0
    for i in args:
        sum += i
    print(sum)

    
add_num(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

def test(**kwargs):			# **两个后面加变量(变量名可以自定义)，这样后面传多个值(需要传关键字参数)，并且结果为字典
    print(kwargs)

    
test(name="zhangsan", age=18, gender="M")

def people(name, *args, age=18, **kwargs):
    print(name)
    print(args)
    print(age)
    print(kwargs)

    
people("zhangsan", "man", 25, salary=20000, department="IT")
people("zhangsan", "man", 180, age=25, salary=20000, department="IT")
people("zhangsan", "man", 180, 25, salary=20000, department="IT")

def test(a, b):
    c = a + b
    return c
	print("haha")	# 返回值后面的代码不执行,也就是说函数执行到return就结束了

test(1, 2)		# 再回顾一下，这是函数的调用，执行函数体内的代码，但这样得不到函数返回值

d = test(1, 2)
print(d)			# 这样终于得到函数的返回值了

print(test(1,2))	# 不赋值给变量，直接打印也是可以得到函数的返回值

def test1(a, b):
    print(a + b)


def test2(a ,b):
    c = a + b
    return c

test1(1, 2)

print(test2(2, 3))

def aaa():
    print("aaa")
def bbb():
    print("bbb")
    aaa()
bbb()


def bbb():
    print("bbb")
    aaa()
def aaa():
    print("aaa")
bbb()

def bbb():
    print("bbb")
    aaa()
bbb()
def aaa():
    print("aaa")

def max_num2(a, b):
    if a > b:
        return a
    else:
        return b
    
def max_num3(n1, n2, n3):
    aaa = max_num2(n1, n2)
    bbb = max_num2(aaa, n3)
    return bbb

print(max_num3(1, 2, 3))

name = "zhangsan"   	# 全局变量

def change_name():
    name = "lisi"	# 这个变量只能在函数内生效，也就是局部变量(可以说这个函数就是这个变量的作用域)
    gender = "male"

    
change_name()		
print(name)			# 结果为zhangsan
print(gender)		# 这句会报错，因为它是局部变量，在外面调用不了

name = "zhangsan"   	# 全局变量

def change_name():
    global name,gender     # 这句可以把name改为全局变量，但不建议这样用，如果多次调用函数，这样很容易混乱，容易与外部的变量冲突
    name = "lisi"
    gender = "male"
    print(name)

    
change_name()		# 这句结果为lisi，调用函数内部的print(name)得到的结果
print(name)			# 这句结果为lisi
print(gender)		# 可以调用gender变量了，能打印出结果

def plus_one(n):
    print(n)
    return plus_one(n+1)


plus_one(0)

def abc(n):
    print(n)
    if n//2 > 0:
        return abc(n//2)

    
abc(100)

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

# 自定义函数
def caclulate(a, b):
	print(a + b)

    
caclulate(2, 5)

# 匿名函数
caclulate = lambda a,b:a+b

print(caclulate(2, 5))

# 方法一:
list1=[1,2,3,4,5]

list2=[]
for i in list1:
    i*=2
    list2.append(i)

print(list2)

# 方法二:
list1=[1,2,3,4,5]

for i,j in enumerate(list1):
    j=j*2
    list1[i]=j

print(list1)

# 方法三:列表推导式
list1=[i*2 for i in range(1,6)]
print(list1)

list2=list(map(lambda i:i+1,list1))
print(list2)

def higher_funct1(a,b):
        print(abs(a)+abs(b))

higher_funct1(-3,-5)

def higher_funct1(a,b,c):
        print(c(a)+c(b))

higher_funct1(-3,-5,abs)
higher_funct1("hello","world",len)
higher_funct1([1,2,3],[4,5,6],sum)

def higher_funct1(a,b,c):
		return c(a)+c(b)

print(higher_funct1(-3,-5,abs))
print(higher_funct1("hello","world",len))
print(higher_funct1([1,2,3],[4,5,6],sum))

import time

def complex_funct1():
    time.sleep(2)
    print("哈哈，我不复杂!")

def complex_funct2():
    time.sleep(3)
    print("哈哈，我也不复杂!")

def complex_funct3():
    time.sleep(4)
    print("哈哈，我还是不复杂!")

complex_funct1()
complex_funct2()
complex_funct3()

import time

def complex_funct1():
    start_time=time.time()
    time.sleep(2)
    print("哈哈，我不复杂!")
    end_time=time.time()
    print("此函数一共费时{}".format(end_time-start_time))

def complex_funct2():
    start_time=time.time()
    time.sleep(3)
    print("哈哈，我也不复杂!")
    end_time=time.time()
    print("此函数一共费时{}".format(end_time-start_time))

def complex_funct3():
    start_time = time.time()
    time.sleep(4)
    print("哈哈，我还是不复杂!")
    end_time=time.time()
    print("此函数一共费时{}".format(end_time-start_time))

complex_funct1()
complex_funct2()
complex_funct3()

import time

def timer(funct):
    start_time=time.time()
    funct()				# 这里funct后面不接()也可以，但下面的调用里就要写，比如timer(complex_funct1())
    end_time=time.time()
    print("此函数一共费时{}".format(end_time - start_time))

def complex_funct1():
    time.sleep(2)
    print("哈哈，我不复杂!")

def complex_funct2():
    time.sleep(3)
    print("哈哈，我也不复杂!")

def complex_funct3():
    time.sleep(4)
    print("哈哈，我还是不复杂!")
timer(complex_funct1)
timer(complex_funct2)
timer(complex_funct3)			# 这里改变了原有的调用方式

def timer(funct):			# 把下面的多个复杂函数当做参数传给这个timer计时函数（高阶函数）
    def timer_proc():			# 函数里调函数（嵌套函数）
        start_time=time.time()
        funct()				# 执行调用的复杂函数(如complex_funct1()等)，函数的过程会消耗一定的时间
        end_time=time.time()
        print("此函数一共费时{}".format(end_time - start_time))	# 算出时间，也就是我们最终需要的结果，但写在里面这样并不能打印出来，需要在外函数作为返回值
    return timer_proc			# 把嵌套内部函数的值在外面作为返回值，这样就可以被显示

@timer							# 相当于timer(complex_funct1)
def complex_funct1():
    time.sleep(2)
    print("哈哈，我不复杂!")

@timer							# 相当于timer(complex_funct2)
def complex_funct2():
    time.sleep(3)
    print("哈哈，我也不复杂!")

@timer							# 相当于timer(complex_funct3)
def complex_funct3():
    time.sleep(4)
    print("哈哈，我还是不复杂!")


complex_funct1()
complex_funct2()
complex_funct3()			# 没有改变最原始的函数调用方式就能实现需求

# python3.6
>>> import sys
>>> print(sys.path)		# 模块路径列表,第一个值为空代码当前目录
['', '/usr/local/lib/python36.zip', '/usr/local/lib/python3.6', '/usr/local/lib/python3.6/lib-dynload', '/root/.local/lib/python3.6/site-packages', '/usr/local/lib/python3.6/site-packages']
# sys.path和linux上的$PATH很类似，如果两个目录里分别有同名模块，则按顺序来调用目录靠前的。
# sys.path的结果是一个列表，所以你可以使用sys.path.append()或sys.path.insert()增加新的模块目录。

def funct1():
    print("funct1")
    
def funct2():
    print("funct2")

def funct3():
    return "funct3"

if __name__ == "__main__":
    print("haha")		# 直接执行hello.py文件会执行这段代码 
else:
    print("hehe")		# 当hello.py以模块形式被调用时执行这段代码

import hello		# 调用同目录的hello模块

hello.funct1()		# 可以调用hello模块里的funct1()函数
hello.funct2()		# 可以调用hello模块里的funct2()函数
print(hello.funct3()) # 调用hello模块里的funct3()函数，因为结果为函数返回值，所以还需要print打印

import hello

import module1,module2,module3

import module1
import module2
import module3

from hello import *

from hello import funct1,funct2

# 代码一:
import hello
hello.funct1()			# 前面要接模块名

# 代码二:
from hello import *
funct1()				# 前面不用模块名了

# 代码三:
import hello
def funct1():
    print("local funct1")	
    
hello.funct1()			# 调用模块里的funct1
funct1()				# 调用本地的funct1

# 代码四:
from hello import *
def funct1():
    print("local funct1")
    
#hello.funct1()			# hello模块里的funct1与本地的funct1冲突了
funct1()				# 得到的是本地的funct1结果

from hello import funct1 as funct1_hello

from hello import funct1 as funct1_hello

def funct1():
   print("local funct1")

funct1_hello()		# 用别名来调用hello模块里的funct1
funct1()			# 本地的funct1

import hello
hello.funct1()    # 如果本文件有大量的地方需要这样调用，那么也就是说需要大量重复找hello模块里的funct1函数

from hello import funct1
funct1()      	  # 如果本文件有大量的地方需要这样调用，这样就不用大量重复查找hello模块了，因为上面的导入就相当于把funct1的函数代码定义到本文件了;而且这样导入方式可以选择性的导入部分函数。