Python基础语法学习

now = True

if __name__ == '__main__':
    if now:
        print("这是true")
    now = False
    if now:
        print("这是true")
    if not now:
        print("这是false", now)
        print("这是false", + \
              now)

if True:
    print("Answer")
    print ("True")
else:

    print ("Answer")
print ("False")
print ((1 + 2j)*2)


word = '字符串aa'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
print(word*2,sentence,paragraph)

zhuanyiBU = "this is a line with \n"
print(zhuanyiBU)
zhuanyi = r"this is a line with \n"
print(zhuanyi)

strmy = '123456789'

print(strmy)  # 输出字符串
print(strmy[0:-2])
print(strmy[2:5])
print(strmy[2:])             # 输出从第三个开始后的所有字符
print(strmy[1:8:2])     # 2468     输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(strmy[1:8:3])     # 258
print("结束")
print(strmy * 2)             # 输出字符串两次
print(strmy + '你好')
print("结束")

print('------------------------------')

print('hello\nrunoob')  # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')  # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

# input("\n\n按下 enter 键后退出。")

import sys; x = '同一行'; sys.stdout.write(x + '\n')

print('------------------------------')
x = "a"
y = "b"
# 换行输出
print(x)
print(y)

print('---------')
# 不换行输出
print(x, end=" AA ")
print(y, end=" ")
print()

'''
import module，引用模块中的变量时要用module.变量名；
from module import *，引用模块中变量时只需直接使用变量名
import module，使用模块中的变量时，使用的是原模块中的变量，不会创建新的变量；
from module import *，使用模块中的变量时，会把原模块中的变量复制到本地，会创建新的对象。开发中建议用import module。
'''

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print (len(sys.argv))
print (sys.path)
print (len(sys.path))
print (sys.path[1])


print ('\n python 路径为',sys.path);

from sys import argv, path  # 导入特定的成员

print('================python from import===================================')
print('path:', path)  # 因为已经导入path成员，所以此处引用时不需要加sys.path

bbbb = True
print(type(bbbb))
cc = 1
print(type(cc))
dd = bbbb + cc
print(dd)
print(type(dd))

print('================基本数据类型===================================')
print(isinstance(bbbb,int)) # True
print(isinstance(bbbb,bool)) # True
print(isinstance(dd,int)) # True
print(isinstance(dd,bool)) # False

print('==========从 python 3.8 开始，使用 is 和 is not 运算符时，会抛出 SyntaxWarning 语句警告信息，建议分别使用 == 和 != 代替。=======')
print(1 is True) # False
print(0 is False) # False
print(True is 1) # False
print(False is 0) # False
print(True == 1) # True
print(False == 0) # True


var1 = '1231'
print(var1)
var1 = '2222' \
       '312312'
print(var1) # 2222312312 反斜杠(\)可以作为续行符，表示下一行是上一行的延续。
var1 = '''2222
       312312'''
print(var1) # 可以使用 """...""" 或者 '''...''' 跨越多行。
del var1
# print(var1) # NameError: name 'var1' is not defined.    del之后这个变量就不存在了。

var1 = '012345'
# var1[2] = '1' # TypeError: 'str' object does not support item assignment   Python 字符串不能被改变。向一个索引位置赋值，会导致错误。
print(var1)
print(var1[2:])
print(var1[-2:])
print(var1[:4])

hhhh = 70.2E-12
print(type(hhhh))
print('==========list=======')

list1 = [0,1,2,3,4,5,6,7,8,9]
print(list1)
list1 = list1[1::-1]
print(list1) # [1, 0]

list1 = [0,1,2,3,4,5,6,7,8,9]
list2 = list1[5:8:1]
print(list2) # [5, 6, 7]
list2 = list1[5:8:-1]
print(list2) # [] 倒着拿，5到8是反着的，拿不到。
list2 = list1[5:2:-1]
print(list2) # [5, 4, 3]
list2 = list1[7::-2]
print(list2) # [7, 5, 3, 1]

print('==========Tuple=======')

tt = (0,1,2)
print(tt)
tt = (0,1,2,list1)
print(tt)
tt2 = (2,)
print(tt2) # (2,)
tt2 = (2)
print(tt2) # 2 不加逗号只有一个就直接是那一个且那一个的类型了，而不是元组了。
tt2 = (list1,)
print(tt2) # ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)
tt2 = (list1)
print(tt2) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
tt3 = ()
print(tt3) # ()

print('==========Dictionary（字典）=======字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。字典的关键字必须为不可变类型，且不能重复。')
dictmy = {} # 创建空字典使用 { }
dictmy['one'] = "1 - 菜鸟教程"
dictmy[2] = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1,'site': 'www.runoob.com'}

print (dictmy['one'])       # 输出键为 'one' 的值
print (dictmy[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

print('==========构造函数 dict() 可以直接从键值对序列中构建字典如下=================')

dict1 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
print(dict1) # {'Runoob': 1, 'Google': 2, 'Taobao': 3}

dict1 = dict(Runoob=1, Google=2, Taobao=3)
print(dict1) # {'Runoob': 1, 'Google': 2, 'Taobao': 3}

chengfang = 2 ** 5 # 乘方
print(chengfang) # 32
chengfangDict = {x: x**2 for x in (2, 4, 6)}
print(chengfangDict) # {2: 4, 4: 16, 6: 36}

print('==========数据类型转换=================')
num_int = 123
num_str = "456"

print("Data type of num_int:",type(num_int))
print("Data type of num_str:",type(num_str))

# print(num_int+num_str) # unsupported operand type(s) for +: 'int' and 'str'

num_str = int("456")
print(num_int+num_str)


num_str = "456"
num_int = str(num_int)
print(num_int+num_int)


print('==========推导式=======')


a = (x for x in range(1,10))
print(a)
# <generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

print(tuple(a))       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
#(1, 2, 3, 4, 5, 6, 7, 8, 9)

print('==========解释器=======')
# Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

# 在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：#! /usr/bin/env python3
# 然后修改脚本权限，使其有执行权限，命令如下：$ chmod +x hello.py

print('==========运算符=======')
a = '3213124123456789'
if (n := len(a)) > 10: # :=海象运算符，可在表达式内部为变量赋值，比方此处为n赋值a的长度16。Python3.8 版本新增运算符。
    print(f"List is too long ({n} elements, expected <= 10)")

a = 10
b = 60
print(a << 2) # 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
print(b >> 2) # 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

print('==========逻辑运算符=======')
'''
and	x and y	布尔"与"  如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或"  如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
'''

a = 10
b = 20

if (a and b):
    print("1 - 变量 a 和 b 都为 true")
else:
    print("1 - 变量 a 和 b 有一个不为 true")
print(a and b)

if (a or b):
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")
print(a or b)

# 修改变量 a 的值
a = 0 # 0是false，其他数包括负数都是true。
if (a and b):
    print("3 - 变量 a 和 b 都为 true")
else:
    print("3 - 变量 a 和 b 有一个不为 true")
print(a and b)

if (a or b):
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("4 - 变量 a 和 b 都不为 true")
print(a or b)

if not (a and b):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")


print('==========身份运算符=======')
a = 20
b = 20

if (a is b):
    print("1 - a 和 b 有相同的标识")
else:
    print("1 - a 和 b 没有相同的标识")

if (id(a) == id(b)):
    print("2 - a 和 b 有相同的标识")
else:
    print("2 - a 和 b 没有相同的标识")

'''
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
'''

'''
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
'''
a = [1, 2, 3]
b = a
print(b is a) # True b == a
b = a[:]
print(b is a) # False
print(b == a) # True


print('==========数字=======')
# 整型(int) 布尔(bool)是整型的子类型。
# // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
print(7.0//2) # 3.0

print('==========Set集合=======')
'''
集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：
parame = {value01,value02,...}
或者
set(value)

'''
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # 这里演示的是去重功能

print('orange' in basket) #True
print('crabgrass' in basket) #False

a = set('abracadabra')
print(a) #{'d', 'c', 'b', 'a', 'r'}
a2 = set('abracadabra''2342') #{'c', 'd', 'a', 'r', '3', 'b', '4', '2'}
print(a2)

b = set('alacazam')
print(a - b)
print(a | b)
print(a & b)
print(a ^ b) # 不同时包含于a和b的元素

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a) #{'r', 'd'}

print('==========Set集合添加元素=======')
'''  
s.add( x )  
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
'''
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook") # {'Taobao', 'Facebook', 'Google', 'Runoob'}

'''  
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x ) 
x 可以有多个，用逗号分开。
'''
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset) # {1, 3, 'Google', 'Taobao', 'Runoob'}

thisset.update([1,4],[5,6])
print(thisset) # {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

print('==========Set集合移除元素=======')
'''
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )
'''
thisset.discard("qwq")

'''
随机删除集合中的一个元素，语法格式如下：
s.pop() 
'''
print(len(thisset))
thisset.clear()
print(thisset) # set()

print('==========Set拷贝一个集合copy()=======')
sites = {"Google", "Runoob", "Taobao"}
x = sites.copy()
print(x)


print('==========Set差集difference() difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。=======')
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.difference(y)
print(x) # {'apple', 'banana', 'cherry'}
print(z) # {'banana', 'cherry'}

print('==========Set差集difference_update()  =======')
'''
difference_update() 方法用于移除两个集合中都存在的元素。
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
只移除前面x集合的，不移除后面y集合的
'''
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

x.difference_update(y)

print(x) # {'banana', 'cherry'}
print(y) # {'apple', 'microsoft', 'google'}


print('==========Set交集intersection()=======')
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}

result = x.intersection(y, z)

print(result) # {'c'}

'''intersection(set)，set 参数可以不是集合，可以是任何序列。'''
y2 = {1, 2, 3, 4, 'a', 5, 56}

# 字典之外的序列：
y3 = y2.intersection([2]) # list
print(y3) # {2}
y3 = y2.intersection((2,)) # tuple
print(y3) # {2}
y3 = y2.intersection('a') # str
print(y3) # {'a'}

# 而对字典则是与字典的 key 值比较：
y3 = y2.intersection({'a': 2})
print(y3) # {'a'}
y3 = y2.intersection({1: 2})
print(y3) # {1}

x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}

x.intersection_update(y, z)

print(x) # {'c'}

print('==========Set isdisjoint() 方法用于判断两个集合是否 不包含相同的元素，如果不包含返回 True，否则返回 False。=======')
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}

z = x.isdisjoint(y)

print(z) # True

print('==========Set issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。=======')
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}

z = x.issubset(y)
print(z) # True

z = y.issubset(x)
print(z) # False

print('==========Set issuperset() 方法用于判断集合是否是参数集合的父集（判断该方法的参数集合是否为指定集合的子集），如果是则返回 True，否则返回 False。=======')
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}

z = x.issuperset(y)

print(z) # True

print('==========Set symmetric_difference() 方法返回两个集合组成的新集合，但会移除两个集合的重复元素。=======')
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

z = x.symmetric_difference(y)

print(z) # {'google', 'cherry', 'banana', 'runoob'}

'''在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中'''
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

x.symmetric_difference_update(y)

print(x)


print('==========Set union() 并集。=======')
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}

result = x.union(y, z)

print(result) # {'c', 'd', 'f', 'e', 'b', 'a'}


print('==========斐波纳契数列=======')
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
    print(b)
    a, b = b, a+b
'''
其中代码 a, b = b, a+b 的计算方式为先计算右边表达式(右边表达式的执行顺序是从左往右的。)，然后同时赋值给左边，等价于：
n=b
m=a+b
a=n
b=m
执行以上程序，输出结果为：

1
1
2
3
5
8
'''


print('==========end 关键字可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符=======')
a, b = 0, 1
while b < 10:
    print(b, end=',')
    a, b = b, a+b
print()
'''
执行以上程序，输出结果为：
1,1,2,3,5,8,
且由于上面的print都加了end不会换行，所以最后再来个print()使最后换行，且需要和while平级使最后的一句不在循环里。
'''


print('==========条件控制 if – elif – else =======')
'''
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

在Python中没有switch – case语句。
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
'''
var1 = 100
if var1:
    print("1 - if 表达式条件为 true")
    print(var1)

var2 = 0
if var2:
    print("2 - if 表达式条件为 true")
    print(var2)
print("Good bye!")
'''
执行结果：var2 为 0 为false
1 - if 表达式条件为 true
100
Good bye!
'''

print('==========条件控制示例：狗的年龄计算判断=======')
age = int(input("请输入你家狗狗的年龄: "))
# 此处int()函数将输入的字符串转为数字类型，否则后面比较大小报错：TypeError: '<=' not supported between instances of 'str' and 'int'
print("")
if age <= 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age - 2) * 5
    print("对应人类年龄: ", human)

### 退出提示
# input("点击 enter 键退出")



print('==========条件控制示例：数字的比较运算=======')
# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字："))

    if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

print('==========循环语句 Python 中的循环语句有 for 和 while。=======')
'''
while 判断条件(condition)：
    执行语句(statements)……
'''

n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n, sum))

print('==========无限循环=======')
'''
var = 1
while var == 1:  # 表达式永远为 true
    num = int(input("输入一个数字  :"))
    print("你输入的数字是: ", num)

print("Good bye!")
'''

print('==========while 循环使用 else 语句：如果 while 后面的条件语句为 false 时，则执行 else 的语句块。 =======')
'''
while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>
'''

print('==========while 循环 简单语句组 :类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中=======')
'''
flag = 1
 
while (flag): print ('欢迎访问菜鸟教程!')
 
print ("Good bye!")
'''

print('==========for 语句：Python for 循环可以遍历任何可迭代对象，包括字符串。=======')
'''
for <variable> in <sequence>:
    <statements>
else:
    <statements>
'''
languages = ["C", "C++", "Perl", "Python"]
for x in languages:
    print (x)

print('==========for 语句：break 语句用于跳出当前循环体=======')
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
'''
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!
'''






print('==========结束=======')