Python语法简洁优雅；Al，大数据把Python推向巅峰，大环境决定了Python的前景，因此作为自己的第三语言，跟java一样可以跨平台、面向对象
Python 是一种脚本语言：顾名思义脚本语言需要有相应的脚本引擎才可以运行，脚本语言有很多种,所以不同的语言需要不同的解释器。比如c语言的Cpython，java的Jython 还有python的PyPy
默认情况下，Python 源码文件的编码是 UTF-8
输入文件结束符（Unix 里是 Control-D，Windows 里是 Control-Z），如果不能退出，还可以输入这个命令：quit()
# -*- coding: UTF-8 -*-
# 文件名：test.py
# 第一个注释
print ("Hello, Python!") # 第二个注释
#等待用户输入
#raw_input函数在python3中被移除
#raw_input("按下 enter 键退出，其他任意键显示...\n")
#input等待用户输入
input("按下 enter 键退出，其他任意键显示...\n")
#定义两个变量
x="a"
y="b"
# 换行输出
print (x)
print (y)
#使用 end 参数实现不换行输出
print ('---------')
print(x, end=' ')
print(y, end=' ')
print ('---------')
# 不换行输出
print (x,y)
#if else 判断分支
x = 42
if x > 50:
print("x is greater than 50")
elif x == 50:
print("x is exactly 50")
else:
print("x is less than 50")
#赋值输出
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print (counter)
print (miles)
print (name)
#多个变量赋值
a, b, c = 1, 2.1, "john"
print (a, b, c)
#Numbers（数字）
#int（有符号整型）
#long（长整型，也可以代表八进制和十六进制）
#float（浮点型）
#complex（复数）
#String（字符串）
#List（列表）
#Tuple（元组）
#Dictionary（字典）
#del 用法：del语句删除一些对象的引用
x = 10
y = "hello"
z = [1, 2, 3]
# 删除单个变量
del x
# 删除多个变量
del y, z
# 在列表中使用 del 删除特定索引的元素
my_list = [1, 2, 3, 4, 5]
del my_list[2] # 删除索引为2的元素，即第3个元素
print(my_list) # 输出: [1, 2, 4, 5]
#字符串
str = 'Hello World!'
print (str) # 输出完整字符串
print (str[0]) # 输出字符串中的第一个字符
print (str[2:5]) # 输出字符串中第三个至第六个之间的字符串
print (str[2:]) # 输出从第三个字符开始的字符串
print (str * 2) # 输出字符串两次
print (str + "TEST") # 输出连接的字符串
#列表
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print (list) # 输出完整列表
print (list[0]) # 输出列表的第一个元素
print (list[1:3]) # 输出第二个至第三个元素,（不包含3）结果：786 , 2.23
print (list[2:]) # 输出从第三个开始至列表末尾的所有元素（包含2）
print (tinylist * 2) # 输出列表两次
print (list + tinylist) # 打印组合的列表
print ("--------------")
#元组
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输第二个至第三个元素（不包含3） (786, 2.23)
print (tuple[2:]) # 输出从第三个开始至列表末尾的所有元素
print (tinytuple * 2) # 输出元组两次
print (tuple + tinytuple) # 打印组合的元组
#tuple[2] = 1000 # 元组中是非法应用
list[2] = 1000 # 列表中是合法应用，修改下标2的元素值
print (list)
print ("-------字典-------")
#字典
#字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
#两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print (dict['one']) # 输出键为'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
#数据转换
#int(x [,base]) 是一个函数，用于将一个字符串或数字 x 转换为一个整数。这个函数有两个参数：
#x：要转换为整数的值，可以是字符串、整数或浮点数。
#base：可选参数，指定 x 的进制。默认情况下，base 是 10。 如 "0x1a" 表示十六进制
print (int("123")) # 返回 123，使用默认的十进制
print(int(float("3.14"))) # 返回 3，小数部分被丢弃,你希望将字符串 "3.14" 转换为整数，你需要首先将其转换为浮点数，然后再转换为整数
print (int("0x1a", 16)) # 返回 26，将十六进制的字符串转换为十进制整数
print (int("101", 2)) # 返回 5，将二进制字符串 "101" 转换为十进制整数
print (int("10", 8)) # 返回 8，将八进制字符串 "10" 转换为八进制整数
基础运用：
cmd窗口执行python Test.py
1.文件名.py
2.注释 #，''',"""
3.print()打印，input键盘输入，enter键退出
4.定义变量：x='a'
5.if else判断分支、while循环、for循环
#条件语句
name = 'python'
if name == 'python': # 判断变量是否为 python
print ('welcome boss') # 并输出欢迎信息
else:
print (name) # 条件不成立时输出变量名称
num = 2
if num == 3: # 判断num的值
print ('boss')
elif num == 2:
print ('user')
elif num == 1:
print ('worker')
elif num < 0: # 值小于零时输出
print ('error')
else:
print ('roadman') # 条件均不成立时输出
# while 循环
i = 1
while i < 10:
i += 1
if i%2 > 0: # 非双数时跳过输出
continue
print (i) # 输出双数2、4、6、8、10
print ("---------------")
j = 1
while 1: # 循环条件为1必定成立
print (j) # 输出1~10
j += 1
if j > 10: # 当i大于10时跳出循环
break
print ("---------------")
# for 循环
fruits = ['banana', 'apple', 'mango']
for fruit in fruits:
print ('当前水果: %s'% fruit)
print ("---------------")
#序列索引迭代
for index in range(len(fruits)):
print ('当前水果 : %s' % fruits[index])
print ("---------------")
for num in range(10,20): # 迭代 10 到 20 (不包含) 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print ('%d 等于 %d * %d' % (num,i,j))
break # 跳出当前循环
else: # 循环的 else 部分
print ('%d 是一个质数' % num)
#嵌套循环
i = 2
while(i < 100):
j = 2
while(j <= (i/j)):
if not(i%j): break
j = j + 1
if (j > i/j) : print (i, " 是素数")
i = i + 1
# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print ('这是 pass 块')
print ('当前字母 :', letter)6.变量类型
#Numbers（数字）
#int（有符号整型）
#long（长整型，也可以代表八进制和十六进制）(python long移除)
#float（浮点型）
#complex（复数）
#String（字符串）
#List（列表）
#Tuple（元组）
#Dictionary（字典）
7.数据转换
#python基本函数
# str(x)转字符串
xwx = 10
newX = str(xwx)
print(newX) # 输出 "10"
#作用类似于 str(x)
xx = 10
print(repr(xx)) # 输出为 "10"
#eval() 函数执行的是字符串中表示的有效Python代码，而不是直接执行字符串本身的内容
var_name = 'ss'
ss= 42
str_expr = var_name + ' * 2'
result = eval(str_expr)
print(result) # 输出为 84，因为 eval('ss * 2') 使用了变量 ss 的当前值
#tuple(s) 是一个将序列 s 转换为元组的内置函数调用
#将列表转换为元组
list_example = [1, 2, 3, 4, 5]
tuple_from_list = tuple(list_example)
print(tuple_from_list) # 输出为 (1, 2, 3, 4, 5)
#将字典的键转换为元组
dict_example = {'a': 1, 'b': 2, 'c': 3}
tuple_from_dict_keys = tuple(dict_example.keys())
print(tuple_from_dict_keys) # 输出为 ('a', 'b', 'c')
#将字符串转换为元组
str_example = "hello"
tuple_from_str = tuple(str_example)
print(tuple_from_str) # 输出为 ('h', 'e', 'l', 'l', 'o')
#list(s) 将可迭代对象 s 转换为一个列表
#将字符串转换为列表
sa = "Hello"
lst = list(sa)
print(lst) # 输出 ['H', 'e', 'l', 'l', 'o']
#将字典的键转换为列表
sb = {"a": 1, "b": 2, "c": 3}
lst = list(sb)
print(lst) # 输出 ['a', 'b', 'c']
#set(s) 这个表达式的意思是将可迭代对象 s 转换为一个集合，并且会自动去除重复的元素(无序、唯一)
#将字符串转换为集合，无序性是集合数据结构的特性，与字典（dict）类似，但与列表（list）和元组（tuple）不同，它们保留了元素的插入顺序
sc = "Hello"
sta = set(sc)
print(sta) # 输出 {'e', 'H', 'l', 'o'}
#将元组转换为集合
sd = (1, 2, 3, 2, 1)
stb= set(sd)
print(stb) # 输出 {1, 2, 3}
#dict(d)创建一个字典。d 必须是一个序列 (key,value)元组;
#d 是一个包含键值对的可迭代对象，如列表、元组或其他字典，dict(d) 将尝试将其转换为一个字典
#d 是一个字典本身，那么 dict(d) 将返回一个与 d 相同的新字典（即浅拷贝）
#将包含键值对元组的列表转换为字典
se = [("a", 1), ("b", 2), ("c", 3)]
sf = dict(se)
print(sf) # 输出 {'a': 1, 'b': 2, 'c': 3}
#将包含键值对的元组转换为字典
sh = (("x", 10), ("y", 20), ("z", 30))
sj = dict(sh)
print(sj) # 输出 {'x': 10, 'y': 20, 'z': 30}
#使用字典的键和值的集合来创建字典
sk = {"a", "b", "c"}
sl = [1, 2, 3]
sm = dict(zip(sk, sl))
print(sm) # 输出 {'a': 1, 'b': 2, 'c': 3}
#frozenset(s)创建不可变集合（frozen set）的函数调用。不可变集合与普通集合（set）类似，但是具有不可变性质，即一旦创建就不能修改其内容或大小
sn = {1, 2, 3, 4}
so = frozenset(sn)
print(so) #输出: frozenset({1, 2, 3, 4})
sp = "Word"
sq = frozenset(sp)
print(sq) #输出:frozenset({'o', 'W', 'r', 'd'}) 由于不可变集合的内容不会变化，因此它们可以作为字典的键或集合的元素，保证了哈希值的稳定性
#chr(x)将一个整数转换为Unicode字符
sv=86
sw=chr(sv)
print(sw)
8运算符及运算顺序
#python 运算符 整数除整数，只能得出整数。如果要得到小数部分，把其中一个数改成浮点数即可
x = 12
y = 5
z = x//y
print(z) #输出2
aa = 12
bb = float(5)
cc = aa/bb
dd = aa//bb
print(cc) #输出2.4
print(dd) #输出2.0
a = 21
b = 10
c = 0
d = 2
a %= d
print(a) #输出1 取余
b**= d
print(b) #b的d次幂 10**2=100
if a == b :
print("1 - a 等于 b")
else:
print("1 - a 不等于 b")
if a != b :
print("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if a < b :
print ("4 - a 小于 b")
else:
print ("4 - a 大于等于 b")
if a > b :
print ("5 - a 大于 b")
else:
print ("5 - a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5
b = 20
if a <= b :
print ("6 - a 小于等于 b")
else:
print ("6 - a 大于 b")
if b >= a :
print ("7 - b 大于等于 a")
else:
print ("7 - b 小于 a")
#位运算
# &按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
# |按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
# ^按位异或运算符：当两对应的二进位相异时，结果为1
# ~按位取反运算符：将二进制表示中的每一位取反，0 变为 1，1 变为 0。~x 类似于 -x-1
#<<左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0
#>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
j = 60 # 60 = 0011 1100
k = 13 # 13 = 0000 1101
l = j & k; # 12 = 0000 1100
print(l)
m = j | l; # 61 = 0011 1101
print(m)
n = j ^ k; # 49 = 0011 0001
print(n)
o = ~j; # -61 = 1100 0011
print(o)
p = j << 2; # 240 = 1111 0000
print(p)
q = j >> 2; # 15 = 0000 1111
print(q)
#逻辑运算符
#and x and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
#or x or y 布尔"或" - 如果 x 为 True，则返回 x。如果 x 为 False，则返回 y
#not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
xa = True
ya = False
result = xa and ya
print(result) # 输出: False
xx = True
yy = True
result = xx and yy
print(result) # 输出: True
xb = True
yb = 10
result = xb and yb
print(result) # 输出: 10
xc = False
yc = True
result = xc and yc
print(result) # 输出: False
print("---------------")
xd = True
yd = False
result = xd or yd
print(result) # 输出:xd值： True
xe = False
ye = 10
result = xe or ye
print(result) # 输出: ye值：10
result=not(xd or yd)
print(result) # 输出:False
print("----------------------")
#成员运算符
#in 如果在指定的序列中找到值返回 True，否则返回 False
#not in 如果在指定的序列中没有找到值返回 True，否则返回 False
wa = 3
wb = 20
list = [1, 2, 3, 4, 5 ];
if ( wa in list ):
print( "1 - 变量 wa 在给定的列表中 list 中")
else:
print( "1 - 变量 wa 不在给定的列表中 list 中")
if ( wb not in list ):
print( "2 - 变量 wb 不在给定的列表中 list 中")
else:
print( "2 - 变量 wb 在给定的列表中 list 中")
#身份运算符
#is 是判断两个标识符是不是引用自一个对象，x is y, 类似 id(x) == id(y) ,
#is not 是判断两个标识符是不是引用自不同对象，x is not y ， 类似 id(a) != id(b)
# id() 函数用于获取对象内存地址
qa = 20
qb = 20
print( qa is qb ) #输出true
print( qa is not qb ) #输出false
#括号 ()：最高优先级，括号中的表达式最先计算。
#指数运算 **：次高优先级，例如 2 ** 3 表示 2 的 3 次方。
#正负号 +x, -x：一元加号和减号。
#乘法、除法、取模和整除 * / % //：乘法 *、除法 /、取模 %（取余数）和整除 //（取整除法）。
#加法和减法 + -：加法 + 和减法 -。
#比较运算符 < <= > >= == !=：比较运算符，用于比较两个值的大小关系。
#赋值运算符 =：赋值运算符，将右边的值赋给左边的变量。
#逻辑运算符 not、and、or：逻辑非 not、逻辑与 and、逻辑或 or。9.时间
import time # 引入time模块
import calendar
ticks = time.time()
print ("当前时间戳为:", ticks)
localtime = time.localtime(time.time())
print ("本地时间为 :", localtime)
localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)
# 格式化成2014-08-02 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成Fri Aug 02 13:22:10 2024
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 将格式字符串转换为时间戳 1722576130.0
a = "Fri Aug 02 13:22:10 2024"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
cal = calendar.month(2024, 8)
print ("以下输出2014年8月份的日历:")
print (cal)10函数
def printme( str ):
"打印传入的字符串到标准显示设备上"
print (str)
return
# 调用函数
printme("我要调用用户自定义函数!")
# 传不可变对象实例
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print (b) # 结果是 2
# 可变函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
#关键字参数顺序不重要
def printinfo( name, age ):
"打印任何传入的字符串"
print ("Name: ", name)
print ("Age ", age)
return
#调用printinfo函数
printinfo( age=28, name="xiaomi" )
# 可写函数说明 不定长参数
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)