bool DirectoryIterator::isWritable (void)Parameters:This function takes no parameters.Return Value:This function returns TRUE if the file / directory is writable, otherwise it returns FALSE.The following programs illustrate the DirectoryIterator::isWritable() function in PHP:Program 1:
// Create an Iterator directory
$directory
=
new
DirectoryIterator (dirname (
__ FILE__
));
// loop is performed for each element
foreach
(
$directory
as
$dir
) {
// Check for writable element
if
(
$dir
-> isWritable()) {
// Show file name
echo
$dir
-> getFilename().
"< br >"
;
}
}
?>
Output:. .. applications.html bitnami.css dashboard favicon.ico engineer.PNG gfg.php img index.php Sublime Text Build 3211 x64 Setup.exe webalizer xampp
Program 2:
// Create the Iterator directory
$directory
=
new
DirectoryIterator (dirname (
__ FILE__
));
// Loop while the catalog item is valid
while
(
$directory
-> valid()) {
// Check for writable element
if
(
$directory
-> isWritable() ) {
// Show file name
echo
$directory
-> getFilename().
"< br >"
;
}
// Move to next item
$directory
-> next();
}
?>
Output:. .. applications.html bitnami.css dashboard favicon.ico engineer.PNG gfg.php img index.php Sublime Text Build 3211 x64 Setup.exe webalizer xampp
Note . The output of this function depends on the contents of the server folder.Link: https : //www.php.net/manual/en/directoryiterator.iswritable.php
PHP DirectoryIterator isWritable () Function: StackOverflow Questions
os.path.dirname(__file__) returns empty
I want to get the path of the current directory under which a .py file is executed.
For example a simple file D: est.py
with code:
import os
print os.getcwd()
print os.path.basename(__file__)
print os.path.abspath(__file__)
print os.path.dirname(__file__)
It is weird that the output is:
D:
test.py
D: est.py
EMPTY
I am expecting the same results from the getcwd()
and path.dirname()
.
Given os.path.abspath = os.path.dirname + os.path.basename
, why
os.path.dirname(__file__)
returns empty?
Answer #1:
Because os.path.abspath = os.path.dirname + os.path.basename
does not hold. we rather have
os.path.dirname(filename) + os.path.basename(filename) == filename
Both dirname()
and basename()
only split the passed filename into components without taking into account the current directory. If you want to also consider the current directory, you have to do so explicitly.
To get the dirname of the absolute path, use
os.path.dirname(os.path.abspath(__file__))
What is the difference between os.path.basename() and os.path.dirname()?
What is the difference between os.path.basename()
and os.path.dirname()
?
I already searched for answers and read some links, but didn"t understand.
Can anyone give a simple explanation?
Answer #1:
Both functions use the os.path.split(path)
function to split the pathname path
into a pair; (head, tail)
.
The os.path.dirname(path)
function returns the head of the path.
E.g.: The dirname of "/foo/bar/item"
is "/foo/bar"
.
The os.path.basename(path)
function returns the tail of the path.
E.g.: The basename of "/foo/bar/item"
returns "item"
From: http://docs.python.org/3/library/os.path.html#os.path.basename
PHP DirectoryIterator isWritable () Function: StackOverflow Questions
Python"s equivalent of && (logical-and) in an if-statement
Question by delete
Here"s my code:
def front_back(a, b):
# +++your code here+++
if len(a) % 2 == 0 && len(b) % 2 == 0:
return a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):]
else:
#todo! Not yet done. :P
return
I"m getting an error in the IF conditional.
What am I doing wrong?
Answer #1:
You would want and
instead of &&
.
Answer #2:
Python uses and
and or
conditionals.
i.e.
if foo == "abc" and bar == "bac" or zoo == "123":
# do something
Answer #3:
I"m getting an error in the IF conditional. What am I doing wrong?
There reason that you get a SyntaxError
is that there is no &&
operator in Python. Likewise ||
and !
are not valid Python operators.
Some of the operators you may know from other languages have a different name in Python.
The logical operators &&
and ||
are actually called and
and or
.
Likewise the logical negation operator !
is called not
.
So you could just write:
if len(a) % 2 == 0 and len(b) % 2 == 0:
or even:
if not (len(a) % 2 or len(b) % 2):
Some additional information (that might come in handy):
I summarized the operator "equivalents" in this table:
+------------------------------+---------------------+
| Operator (other languages) | Operator (Python) |
+==============================+=====================+
| && | and |
+------------------------------+---------------------+
| || | or |
+------------------------------+---------------------+
| ! | not |
+------------------------------+---------------------+
See also Python documentation: 6.11. Boolean operations.
Besides the logical operators Python also has bitwise/binary operators:
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
There is no bitwise negation in Python (just the bitwise inverse operator ~
- but that is not equivalent to not
).
See also 6.6. Unary arithmetic and bitwise/binary operations and 6.7. Binary arithmetic operations.
The logical operators (like in many other languages) have the advantage that these are short-circuited.
That means if the first operand already defines the result, then the second operator isn"t evaluated at all.
To show this I use a function that simply takes a value, prints it and returns it again. This is handy to see what is actually
evaluated because of the print statements:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
As you can see only one print statement is executed, so Python really didn"t even look at the right operand.
This is not the case for the binary operators. Those always evaluate both operands:
>>> res = print_and_return(False) & print_and_return(True);
False
True
But if the first operand isn"t enough then, of course, the second operator is evaluated:
>>> res = print_and_return(True) and print_and_return(False);
True
False
To summarize this here is another Table:
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
The True
and False
represent what bool(left-hand-side)
returns, they don"t have to be True
or False
, they just need to return True
or False
when bool
is called on them (1).
So in Pseudo-Code(!) the and
and or
functions work like these:
def and(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return evaluate(expr2)
else:
return left
def or(expr1, expr2):
left = evaluate(expr1)
if bool(left):
return left
else:
return evaluate(expr2)
Note that this is pseudo-code not Python code. In Python you cannot create functions called and
or or
because these are keywords.
Also you should never use "evaluate" or if bool(...)
.
Customizing the behavior of your own classes
This implicit bool
call can be used to customize how your classes behave with and
, or
and not
.
To show how this can be customized I use this class which again print
s something to track what is happening:
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
print("__bool__ called on {!r}".format(self))
return bool(self.value)
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
So let"s see what happens with that class in combination with these operators:
>>> if Test(True) and Test(False):
... pass
__bool__ called on Test(True)
__bool__ called on Test(False)
>>> if Test(False) or Test(False):
... pass
__bool__ called on Test(False)
__bool__ called on Test(False)
>>> if not Test(True):
... pass
__bool__ called on Test(True)
If you don"t have a __bool__
method then Python also checks if the object has a __len__
method and if it returns a value greater than zero.
That might be useful to know in case you create a sequence container.
See also 4.1. Truth Value Testing.
NumPy arrays and subclasses
Probably a bit beyond the scope of the original question but in case you"re dealing with NumPy arrays or subclasses (like Pandas Series or DataFrames) then the implicit bool
call
will raise the dreaded ValueError
:
>>> import numpy as np
>>> arr = np.array([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> arr and arr
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> import pandas as pd
>>> s = pd.Series([1,2,3])
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> s and s
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
In these cases you can use the logical and function from NumPy which performs an element-wise and
(or or
):
>>> np.logical_and(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([False, False, True, False])
>>> np.logical_or(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([ True, False, True, True])
If you"re dealing just with boolean arrays you could also use the binary operators with NumPy, these do perform element-wise (but also binary) comparisons:
>>> np.array([False,False,True,True]) & np.array([True, False, True, False])
array([False, False, True, False])
>>> np.array([False,False,True,True]) | np.array([True, False, True, False])
array([ True, False, True, True])
(1)
That the bool
call on the operands has to return True
or False
isn"t completely correct. It"s just the first operand that needs to return a boolean in it"s __bool__
method:
class Test(object):
def __init__(self, value):
self.value = value
def __bool__(self):
return self.value
__nonzero__ = __bool__ # Python 2 compatibility
def __repr__(self):
return "{self.__class__.__name__}({self.value})".format(self=self)
>>> x = Test(10) and Test(10)
TypeError: __bool__ should return bool, returned int
>>> x1 = Test(True) and Test(10)
>>> x2 = Test(False) and Test(10)
That"s because and
actually returns the first operand if the first operand evaluates to False
and if it evaluates to True
then it returns the second operand:
>>> x1
Test(10)
>>> x2
Test(False)
Similarly for or
but just the other way around:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
However if you use them in an if
statement the if
will also implicitly call bool
on the result. So these finer points may not be relevant for you.
How do you get the logical xor of two variables in Python?
Question by Zach Hirsch
How do you get the logical xor of two variables in Python?
For example, I have two variables that I expect to be strings. I want to test that only one of them contains a True value (is not None or the empty string):
str1 = raw_input("Enter string one:")
str2 = raw_input("Enter string two:")
if logical_xor(str1, str2):
print "ok"
else:
print "bad"
The ^
operator seems to be bitwise, and not defined on all objects:
>>> 1 ^ 1
0
>>> 2 ^ 1
3
>>> "abc" ^ ""
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ^: "str" and "str"
Answer #1:
If you"re already normalizing the inputs to booleans, then != is xor.
bool(a) != bool(b)
Answer #2:
You can always use the definition of xor to compute it from other logical operations:
(a and not b) or (not a and b)
But this is a little too verbose for me, and isn"t particularly clear at first glance. Another way to do it is:
bool(a) ^ bool(b)
The xor operator on two booleans is logical xor (unlike on ints, where it"s bitwise). Which makes sense, since bool
is just a subclass of int
, but is implemented to only have the values 0
and 1
. And logical xor is equivalent to bitwise xor when the domain is restricted to 0
and 1
.
So the logical_xor
function would be implemented like:
def logical_xor(str1, str2):
return bool(str1) ^ bool(str2)
Credit to Nick Coghlan on the Python-3000 mailing list.