python基础练习（一）

代码

# 注释1
print('Hello, World!') #注释2

print("厉害!")
if True:
    print("True")
else:
    print("false")

# input("\n\n按下 enter 键后退出。")
#a,b=eval(input())

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

total = 'item_one' + \
        'item_two' + \
        'item_three'
print(total)
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
print(total)

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

strC='Runoob'
 
print(strC)                 # 输出字符串
print(strC[0:-1])           # 输出第一个到倒数第二个的所有字符
print(strC[0])              # 输出字符串第一个字符
print(strC[2:5])            # 输出从第三个开始到第五个的字符
print(strC[2:])             # 输出从第三个开始后的所有字符
print(strC * 2)             # 输出字符串两次
print(strC + '你好')        # 连接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义


expression = 1
if 0 : 
   print('0')
elif 1 : 
   print('1') 
else : 
   print('2')


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

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

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

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
isinstance(a, int)

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
print (list[1:3:2])     #第三个参数，作用是截取的步长


def reverseWords(inputs):
     
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = inputs.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    inputs = 'I like runoob'
    rw = reverseWords(inputs)
    print(rw)

#tuple 元组
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

#set 集合
#基本功能是进行成员关系测试和删除重复元素。
#可以使用大括号 { } 或者 set() 函数创建集合
#注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a 和 b 的差集
 
print(a | b)     # a 和 b 的并集
 
print(a & b)     # a 和 b 的交集
 
print(a ^ b)     # a 和 b 中不同时存在的元素

#dictionary字典
'''
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
'''
#dict = {}
#dict['one'] = "1 - 菜鸟教程"
#dict[2]     = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.china.com'}
 
#print (dict['one'])       # 输出键为 'one' 的值
#print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)]) #要注释掉前面自定义dict
{x: x**2 for x in (2, 4, 6)}
dict(Runoob=1, Google=2, Taobao=3)


'''
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
'''

class Solution:
    # bin函数： bin返回一个整数的二进制字符串，以0b开头，
    # bin(10) '0b1010'  bin(-10)  '-0b1010'
    #
    # count函数 返回字符串当中非重叠的字符串的个数，可以传入start，end来表示对字符串切片的结果
    #
    #如果一个数为负数，那么2**32 + n 然后再用bin返回的就是它的补码形式。 补码+源码=2**32
    def NumberOf1(self, n):
        if n >= 0:
            return bin(n).count('1')
        else:
            return bin(2**32 + n).count('1')
 
if __name__ == '__main__':
    solution = Solution()
    print(solution.NumberOf1(10))
    print(solution.NumberOf1(-1))

c = -15
print(bin(2**8 + c))

a = 10 #其二进制值为0b00111100
n = 0 #用于计数
while a: #用移位方法求解，直到a移位为0为止
    if a & 1 == 1:
        n += 1 #将a与1进行位与操作，即可知道a的最后1位是否为1，若为1，则计数n增1，不然则无需变化n的值
    a >>= 1 #测试了a的最后一位后，将最后一位右移移除，重新赋值给a
print(n) #打印最后的计数数据

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
para_strs = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print (para_strs)

#f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，
#它会将变量或表达式计算后的值替换进去
name = 'Runoob'
print(f'Hello {name}')
x = 1
print(f'{x+1}')

strA = "this Is String Example From Runoob....Wow!!!"
print ("strA.capitalize() : ", strA.capitalize())

#nA = input("")
nA = "235345"
sA = "〇一二三四五六七八九"
for cA in "0123456789": 
  nA = nA.replace(cA, sA[eval(cA)])
print(nA)


#列表
list = ['Google', 'Runoob', 1997, 2000] 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
print ("更新后的右第三个元素为 : ", list[-2])
del list[2]
print ("删除第三个元素 : ", list)
list.append('Baidu')
print ("更新后的列表 : ", list)
for x in [1, 2, 3]: print(x, end=" ") #迭代


#集合
'''
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
'''
#增加
print('\n')
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
thisset.update("FaFF")
thisset.update({"FaFF"})
print(thisset)
#删除
thisset.remove('Runoob')
thisset.discard("aaaa")
print(thisset)
#随机删除一个
xset = thisset.pop()
print(xset)
print(thisset)
#个数
print("length = "+ str(len(thisset)))
#清空
thisset.clear()
print(thisset)

nA = input("")
sA = "〇一二三四五六七八九"
for c in "0123456789": 
  nA = nA.replace(c, sA[eval(c)])
print(nA)

结果

Hello, World!
厉害!
True
runoob
item_oneitem_twoitem_three
['item_one', 'item_two', 'item_three', 'item_four', 'item_five']
这是一个段落，
可以由多行组成
Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoob你好
------------------------------
hello
runoob
hello\nrunoob
1
a
b
---------
a b 
================Python import mode==========================
命令行参数为:
D:\python\hello.py

 python 路径为 ['D:\\python', 'D:\\Program Files\\Python\\Python37\\python37.zip', 'D:\\Program Files\\Python\\Python37\\DLLs', 'D:\\Program Files\\Python\\Python37\\lib', 'D:\\Program Files\\Python\\Python37', 'D:\\Program Files\\Python\\Python37\\lib\\site-packages']
================python from import===================================
path: ['D:\\python', 'D:\\Program Files\\Python\\Python37\\python37.zip', 'D:\\Program Files\\Python\\Python37\\DLLs', 'D:\\Program Files\\Python\\Python37\\lib', 'D:\\Program Files\\Python\\Python37', 'D:\\Program Files\\Python\\Python37\\lib\\site-packages']
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
[786]
runoob like I
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
{'Jack', 'Tom', 'Rose', 'Jim', 'Mary'}
Rose 在集合中
{'b', 'a', 'r', 'd', 'c'}
{'r', 'b', 'd'}
{'z', 'b', 'a', 'm', 'r', 'l', 'd', 'c'}
{'c', 'a'}
{'z', 'r', 'b', 'd', 'l', 'm'}
{'name': 'runoob', 'code': 1, 'site': 'www.china.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.china.com'])
2
32
0b11110001
2
我叫 小明 今年 10 岁!
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( 	 )。
也可以使用换行符 [ 
 ]。

Hello Runoob
2
strA.capitalize() :  This is string example from runoob....wow!!!
二三五三四五
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的右第三个元素为 :  2001
删除第三个元素 :  ['Google', 'Runoob', 2000]
更新后的列表 :  ['Google', 'Runoob', 2000, 'Baidu']
1 2 3 

{'Runoob', 'a', 'Taobao', 'Google', 'FaFF', 'F', 'Facebook'}
{'a', 'Taobao', 'Google', 'FaFF', 'F', 'Facebook'}
a
{'Taobao', 'Google', 'FaFF', 'F', 'Facebook'}
length = 5
set()

3657674765
三六五七六七四七六五